Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Import and refresh selected 1Password items (#8952)
Aaron Pereze604ee3e49e3
diff --git a/alembic/versions/2026_10_18_0902-1db436c126a8_track_1password_credential_items_missing_upstream.py b/alembic/versions/2026_10_18_0902-1db436c126a8_track_1password_credential_items_missing_upstream.pynew file mode 100644index 000000000..7423e1c26--- /dev/null+++ b/alembic/versions/2026_10_18_0902-1db436c126a8_track_1password_credential_items_missing_upstream.py@@ -0,0 +1,29 @@+"""Track 1Password credential items missing upstream.++Revision ID: 1db436c126a8+Revises: 693768f86402+Create Date: 2026-10-18T09:02:51.669010+00:00++"""++from typing import Sequence, Union++import sqlalchemy as sa++from alembic import op++# revision identifiers, used by Alembic.+revision: str = "1db436c126a8"+down_revision: Union[str, None] = "693768f86402"+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.execute("SET LOCAL lock_timeout = '5s'")+ op.add_column("credentials", sa.Column("upstream_missing_at", sa.DateTime(), nullable=True))+++def downgrade() -> None:+ op.execute("SET LOCAL lock_timeout = '5s'")+ op.drop_column("credentials", "upstream_missing_at")diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.jsonindex 40c5cad8f..83c412c47 100644--- a/docs/api-reference/openapi.json+++ b/docs/api-reference/openapi.json@@ -13417,6 +13417,43 @@],"description": "Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom')"},+ "vault_id": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "title": "Vault Id",+ "description": "1Password vault ID for linked credentials"+ },+ "item_id": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "title": "Item Id",+ "description": "1Password item ID for linked credentials"+ },+ "upstream_missing_at": {+ "anyOf": [+ {+ "type": "string",+ "format": "date-time"+ },+ {+ "type": "null"+ }+ ],+ "title": "Upstream Missing At",+ "description": "When the linked 1Password item was last found missing upstream"+ },"browser_profile_id": {"anyOf": [{diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.pyindex e6cd56d47..c47ed6b9e 100644--- a/skyvern/forge/sdk/db/models.py+++ b/skyvern/forge/sdk/db/models.py@@ -1989,6 +1989,7 @@ class CredentialModel(Base):created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)modified_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)+ upstream_missing_at = Column(DateTime, nullable=True)deleted_at = Column(DateTime, nullable=True)diff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.pyindex e247d6833..0590ca112 100644--- a/skyvern/forge/sdk/db/repositories/credentials.py+++ b/skyvern/forge/sdk/db/repositories/credentials.py@@ -1,12 +1,17 @@from __future__ import annotations+from collections.abc import Awaitable, Callable, Sequencefrom datetime import datetime, timezonefrom typing import cast-from sqlalchemy import delete, func, or_, select, update+from sqlalchemy import and_, delete, func, or_, select, update+from sqlalchemy.dialects.postgresql import insert as pg_insert+from sqlalchemy.dialects.sqlite import insert as sqlite_insert+from sqlalchemy.ext.asyncio import AsyncSessionfrom skyvern.forge.sdk.db._error_handling import db_operationfrom skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.datetime_utils import naive_utc_nowfrom skyvern.forge.sdk.db.exceptions import NotFoundErrorfrom skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel, TOTPCodeModelfrom skyvern.forge.sdk.db.repositories.proxy_pin_update import apply_proxy_pin_to_model, normalize_proxy_pin_for_create@@ -111,6 +116,187 @@ class CredentialRepository(BaseRepository):await session.refresh(credential)return Credential.model_validate(credential)+ @db_operation("get_onepassword_credentials")+ async def get_onepassword_credentials(+ self,+ organization_id: str,+ *,+ folder_id: str | None = None,+ folder_id_is_null: bool = False,+ item_keys: Sequence[tuple[str, str]] | None = None,+ limit: int | None = None,+ ) -> list[Credential]:+ if item_keys is not None and not item_keys:+ return []+ async with self.Session() as session:+ query = (+ select(CredentialModel)+ .where(+ CredentialModel.organization_id == organization_id,+ CredentialModel.vault_type == CredentialVaultType.ONEPASSWORD.value,+ CredentialModel.vault_id.is_not(None),+ CredentialModel.item_id.is_not(None),+ CredentialModel.deleted_at.is_(None),+ )+ .order_by(CredentialModel.created_at)+ )+ if folder_id_is_null:+ query = query.where(CredentialModel.folder_id.is_(None))+ elif folder_id is not None:+ query = query.where(CredentialModel.folder_id == folder_id)+ if item_keys is not None:+ query = query.where(+ or_(+ *(+ and_(CredentialModel.vault_id == vault_id, CredentialModel.item_id == item_id)+ for vault_id, item_id in item_keys+ )+ )+ )+ if limit is not None:+ query = query.limit(limit)+ credentials = (await session.scalars(query)).all()+ return [Credential.model_validate(credential) for credential in credentials]++ @db_operation("upsert_onepassword_credential_metadata")+ async def upsert_onepassword_credential_metadata(+ self,+ organization_id: str,+ vault_id: str,+ item_id: str,+ name: str,+ credential_type: CredentialType,+ tested_url: str | None,+ folder_id: str | None,+ created_by: str | None,+ set_folder_on_update: bool = True,+ authorize_update: Callable[[AsyncSession, str], Awaitable[None]] | None = None,+ ) -> tuple[Credential, bool]:+ async with self.Session() as session:+ insert = sqlite_insert if session.get_bind().dialect.name == "sqlite" else pg_insert+ result = await session.execute(+ insert(CredentialModel)+ .values(+ organization_id=organization_id,+ vault_type=CredentialVaultType.ONEPASSWORD.value,+ vault_id=vault_id,+ item_id=item_id,+ name=name,+ credential_type=credential_type.value,+ username=None,+ totp_type="none",+ has_totp_seed=False,+ tested_url=tested_url,+ folder_id=folder_id,+ created_by=created_by,+ upstream_missing_at=None,+ )+ .on_conflict_do_nothing(+ index_elements=[+ CredentialModel.organization_id,+ CredentialModel.vault_id,+ CredentialModel.item_id,+ ],+ index_where=and_(CredentialModel.vault_id.is_not(None), CredentialModel.deleted_at.is_(None)),+ )+ )+ created = result.rowcount == 1+ credential = await session.scalar(+ select(CredentialModel)+ .where(+ CredentialModel.organization_id == organization_id,+ CredentialModel.vault_type == CredentialVaultType.ONEPASSWORD.value,+ CredentialModel.vault_id == vault_id,+ CredentialModel.item_id == item_id,+ CredentialModel.deleted_at.is_(None),+ )+ .with_for_update()+ )+ if credential is None:+ raise RuntimeError("1Password credential upsert did not return a credential row")+ if authorize_update is not None:+ await authorize_update(session, credential.credential_id)+ if not created:+ credential.name = name+ credential.credential_type = credential_type.value+ credential.tested_url = tested_url+ if set_folder_on_update:+ credential.folder_id = folder_id+ credential.upstream_missing_at = None+ await session.commit()+ await session.refresh(credential)+ return Credential.model_validate(credential), created++ @db_operation("update_onepassword_credential_metadata")+ async def update_onepassword_credential_metadata(+ self,+ credential_id: str,+ organization_id: str,+ authorized_folder_id: str | None,+ name: str,+ credential_type: CredentialType,+ tested_url: str | None,+ ) -> bool:+ async with self.Session() as session:+ result = await session.execute(+ update(CredentialModel)+ .where(+ CredentialModel.credential_id == credential_id,+ CredentialModel.organization_id == organization_id,+ CredentialModel.vault_type == CredentialVaultType.ONEPASSWORD.value,+ CredentialModel.folder_id.is_not_distinct_from(authorized_folder_id),+ CredentialModel.deleted_at.is_(None),+ )+ .values(+ name=name,+ credential_type=credential_type.value,+ tested_url=tested_url,+ upstream_missing_at=None,+ modified_at=naive_utc_now(),+ )+ .returning(CredentialModel.credential_id)+ )+ updated = result.scalar_one_or_none() is not None+ await session.commit()+ return updated++ @db_operation("set_onepassword_credentials_stale")+ async def set_onepassword_credentials_stale(+ self,+ organization_id: str,+ credential_folders: Sequence[tuple[str, str | None]],+ *,+ stale: bool,+ ) -> set[str]:+ if not credential_folders:+ return set()+ async with self.Session() as session:+ result = await session.execute(+ update(CredentialModel)+ .where(+ CredentialModel.organization_id == organization_id,+ CredentialModel.vault_type == CredentialVaultType.ONEPASSWORD.value,+ CredentialModel.deleted_at.is_(None),+ or_(+ *(+ and_(+ CredentialModel.credential_id == credential_id,+ CredentialModel.folder_id.is_not_distinct_from(folder_id),+ )+ for credential_id, folder_id in credential_folders+ )+ ),+ )+ .values(+ upstream_missing_at=naive_utc_now() if stale else None,+ modified_at=naive_utc_now(),+ )+ .returning(CredentialModel.credential_id)+ )+ updated_ids = set(result.scalars())+ await session.commit()+ return updated_ids+@db_operation("get_credentials_by_browser_profile_id")async def get_credentials_by_browser_profile_id(self, browser_profile_id: str, organization_id: strdiff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex 89d0496e4..a90239e10 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -43,6 +43,7 @@ import structlogfrom fastapi import BackgroundTasks, Body, Depends, Header, HTTPException, Path, Query, Response, statusfrom onepassword.client import Client as OnePasswordClientfrom onepassword.errors import DesktopSessionExpiredException, RateLimitExceededException+from onepassword.types import Itemfrom sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import AsyncSession@@ -85,6 +86,7 @@ from skyvern.forge.sdk.routes.code_samples import (from skyvern.forge.sdk.routes.routers import base_router, legacy_base_routerfrom skyvern.forge.sdk.routes.trigger_type import workflow_run_trigger_type_from_user_agentfrom skyvern.forge.sdk.schemas.credentials import (+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT,BitwardenItemsResponse,CancelTestResponse,CreateCredentialRequest,@@ -94,11 +96,17 @@ from skyvern.forge.sdk.schemas.credentials import (CredentialType,CredentialVaultType,CreditCardCredentialResponse,+ ImportOnePasswordCredentialsRequest,+ ImportOnePasswordCredentialsResponse,NonEmptyPasswordCredential,+ OnePasswordCredentialImportResult,+ OnePasswordCredentialRefreshResult,OnePasswordItemOverview,OnePasswordItemsResponse,PasswordCredential,PasswordCredentialResponse,+ RefreshOnePasswordCredentialsRequest,+ RefreshOnePasswordCredentialsResponse,SecretCredentialResponse,TestCredentialRequest,TestCredentialResponse,@@ -184,6 +192,9 @@ from skyvern.utils.phone_validation import normalize_identifierfrom skyvern.utils.url_validators import validate_urlLOG = structlog.get_logger()+_ONEPASSWORD_METADATA_TIMEOUT_SECONDS = 20.0+# shortcut: caps refresh at 5 in-flight vault requests; raise only after validating provider rate limits.+_ONEPASSWORD_MAX_CONCURRENT_VAULT_REQUESTS = 5# Strong references to background tasks to prevent GC before completion.# See: https://docs.python.org/3/library/asyncio-task.html#creating-tasks@@ -3304,6 +3315,338 @@ async def list_onepassword_items(return response+async def _organization_onepassword_token(organization_id: str) -> str:+ resolution = await resolve_onepassword_token(organization_id)+ if resolution.source != "organization" or resolution.token is None:+ raise HTTPException(+ status_code=400,+ detail="An organization-level 1Password service account token is required.",+ )+ return resolution.token+++async def _onepassword_metadata_by_vault(+ token: str, vault_ids: set[str], *, fallback_detail: str+) -> dict[str, list[Item]]:+ try:++ async def list_metadata() -> dict[str, list[Item]]:+ client = await OnePasswordClient.authenticate(+ auth=token,+ integration_name="Skyvern",+ integration_version="v1.0.0",+ )+ semaphore = asyncio.Semaphore(_ONEPASSWORD_MAX_CONCURRENT_VAULT_REQUESTS)++ async def list_vault(vault_id: str) -> list[Item]:+ async with semaphore:+ # items.list returns overviews; never fetch item fields during import or refresh.+ return await client.items.list(vault_id)++ sorted_vault_ids = sorted(vault_ids)+ vault_items = await asyncio.gather(*(list_vault(vault_id) for vault_id in sorted_vault_ids))+ return dict(zip(sorted_vault_ids, vault_items, strict=True))++ return await asyncio.wait_for(list_metadata(), timeout=_ONEPASSWORD_METADATA_TIMEOUT_SECONDS)+ except Exception as error:+ raise _onepassword_error_response(error, fallback_detail=fallback_detail) from error+++async def _authorize_onepassword_folder(organization_id: str, folder_id: str | None, action: str) -> None:+ if folder_id is None:+ return+ if await app.DATABASE.credential_folders.get_credential_folder(folder_id, organization_id) is None:+ raise HTTPException(status_code=404, detail=f"Credential folder {folder_id} not found")+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(), action, {("folder_id", folder_id)}+ )+++def _onepassword_item_credential_type(item: Item) -> CredentialType | None:+ category = "".join(character for character in item.category.value.casefold() if character.isalnum())+ return {+ "login": CredentialType.PASSWORD,+ "creditcard": CredentialType.CREDIT_CARD,+ }.get(category)+++def _onepassword_item_url(item: Item) -> str | None:+ return item.websites[0].url if item.websites else None+++@base_router.post(+ "/credentials/onepassword/import",+ response_model=ImportOnePasswordCredentialsResponse,+ include_in_schema=False,+)+@base_router.post(+ "/credentials/onepassword/import/",+ response_model=ImportOnePasswordCredentialsResponse,+ include_in_schema=False,+)+async def import_onepassword_credentials(+ background_tasks: BackgroundTasks,+ data: Annotated[ImportOnePasswordCredentialsRequest, Body()],+ current_org: Annotated[Organization, Depends(org_auth_service.get_current_org_for_credential_routes)],+ current_user_id: Annotated[str | None, Depends(org_auth_service.get_current_user_id_or_none)],+) -> ImportOnePasswordCredentialsResponse:+ organization_id = current_org.organization_id+ await _authorize_onepassword_folder(organization_id, data.folder_id, "credential.create")+ item_keys = sorted({(item.vault_id, item.item_id) for item in data.items})+ existing = await app.DATABASE.credentials.get_onepassword_credentials(+ organization_id,+ item_keys=item_keys,+ )+ existing_by_key = {(credential.vault_id, credential.item_id): credential for credential in existing}+ set_folder_on_update = "folder_id" in data.model_fields_set+ if existing:+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(),+ "credential.update",+ {("credential_id", credential.credential_id) for credential in existing},+ )++ token = await _organization_onepassword_token(organization_id)+ metadata_by_vault = await _onepassword_metadata_by_vault(+ token,+ {vault_id for vault_id, _item_id in item_keys},+ fallback_detail="Failed to import 1Password items.",+ )+ items_by_vault = {+ vault_id: {item.id: item for item in vault_items} for vault_id, vault_items in metadata_by_vault.items()+ }++ async def authorize_upsert(session: AsyncSession, credential_id: str) -> None:+ if data.folder_id is not None:+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(), "credential.create", {("folder_id", data.folder_id)}, session=session+ )+ references = {("credential_id", credential_id)}+ if set_folder_on_update and data.folder_id is not None:+ references.add(("folder_id", data.folder_id))+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(),+ "credential.move" if set_folder_on_update else "credential.update",+ references,+ session=session,+ )++ results: list[OnePasswordCredentialImportResult] = []+ for selection in data.items:+ item = items_by_vault.get(selection.vault_id, {}).get(selection.item_id)+ if item is None:+ results.append(+ OnePasswordCredentialImportResult(+ vault_id=selection.vault_id,+ item_id=selection.item_id,+ status="skipped",+ reason="Item not found in the 1Password vault.",+ )+ )+ continue+ credential_type = _onepassword_item_credential_type(item)+ if credential_type is None:+ results.append(+ OnePasswordCredentialImportResult(+ vault_id=selection.vault_id,+ item_id=selection.item_id,+ status="skipped",+ reason=f"Unsupported 1Password category: {item.category.value}",+ )+ )+ continue++ credential, created = await app.DATABASE.credentials.upsert_onepassword_credential_metadata(+ organization_id=organization_id,+ vault_id=selection.vault_id,+ item_id=selection.item_id,+ name=item.title,+ credential_type=credential_type,+ tested_url=_onepassword_item_url(item),+ folder_id=data.folder_id,+ created_by=current_user_id,+ set_folder_on_update=set_folder_on_update,+ authorize_update=authorize_upsert,+ )+ if created:+ await record_request_audit_event(+ organization_id, "credential.create", "credential", credential.credential_id+ )+ background_tasks.add_task(+ app.AGENT_FUNCTION.on_credential_saved,+ organization_id=organization_id,+ credential_id=credential.credential_id,+ credential_type=credential_type,+ actor_user_id=current_user_id,+ vault=CredentialVaultType.ONEPASSWORD.value,+ )+ else:+ changed_fields = ["name", "credential_type", "tested_url"]+ previous = existing_by_key.get((selection.vault_id, selection.item_id))+ if set_folder_on_update and previous is not None and previous.folder_id != data.folder_id:+ changed_fields.append("folder_id")+ await record_request_audit_event(+ organization_id,+ "credential.update",+ "credential",+ credential.credential_id,+ changed_fields=tuple(changed_fields),+ )+ results.append(+ OnePasswordCredentialImportResult(+ vault_id=selection.vault_id,+ item_id=selection.item_id,+ status="imported" if created else "updated",+ )+ )++ return ImportOnePasswordCredentialsResponse(results=results)+++@base_router.post(+ "/credentials/onepassword/refresh",+ response_model=RefreshOnePasswordCredentialsResponse,+ include_in_schema=False,+)+@base_router.post(+ "/credentials/onepassword/refresh/",+ response_model=RefreshOnePasswordCredentialsResponse,+ include_in_schema=False,+)+async def refresh_onepassword_credentials(+ data: Annotated[RefreshOnePasswordCredentialsRequest, Body()],+ current_org: Annotated[Organization, Depends(org_auth_service.get_current_org_for_credential_routes)],+) -> RefreshOnePasswordCredentialsResponse:+ organization_id = current_org.organization_id+ await _authorize_onepassword_folder(organization_id, data.folder_id, "credential.update")+ folder_id_is_null = "folder_id" in data.model_fields_set and data.folder_id is None+ credentials = await app.DATABASE.credentials.get_onepassword_credentials(+ organization_id,+ folder_id=data.folder_id,+ folder_id_is_null=folder_id_is_null,+ limit=ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT + 1,+ )+ if not credentials:+ return RefreshOnePasswordCredentialsResponse(refreshed=0, stale=0, skipped=0, results=[])++ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(),+ "credential.update",+ {("credential_id", credential.credential_id) for credential in credentials},+ )+ if len(credentials) > ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT:+ raise HTTPException(+ status_code=400,+ detail=(+ f"More than {ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT} 1Password credentials match; "+ "scope the refresh to smaller folders and try again."+ ),+ )+ token = await _organization_onepassword_token(organization_id)+ metadata_by_vault = await _onepassword_metadata_by_vault(+ token,+ {credential.vault_id for credential in credentials if credential.vault_id is not None},+ fallback_detail="Failed to refresh 1Password items.",+ )+ items_by_vault = {+ vault_id: {item.id: item for item in vault_items} for vault_id, vault_items in metadata_by_vault.items()+ }++ missing_credentials: list[tuple[Credential, str, str]] = []+ unsupported_credentials: list[tuple[Credential, Item, str, str]] = []+ results_by_id: dict[str, OnePasswordCredentialRefreshResult] = {}+ refreshed = 0+ skipped = 0+ for credential in credentials:+ vault_id = credential.vault_id+ item_id = credential.item_id+ if vault_id is None or item_id is None:+ continue+ item = items_by_vault.get(vault_id, {}).get(item_id)+ if item is None:+ missing_credentials.append((credential, vault_id, item_id))+ continue+ credential_type = _onepassword_item_credential_type(item)+ if credential_type is None:+ unsupported_credentials.append((credential, item, vault_id, item_id))+ continue+ updated = await app.DATABASE.credentials.update_onepassword_credential_metadata(+ credential_id=credential.credential_id,+ organization_id=organization_id,+ authorized_folder_id=credential.folder_id,+ name=item.title,+ credential_type=credential_type,+ tested_url=_onepassword_item_url(item),+ )+ if updated:+ refreshed += 1+ results_by_id[credential.credential_id] = OnePasswordCredentialRefreshResult(+ vault_id=vault_id,+ item_id=item_id,+ status="refreshed",+ )+ else:+ results_by_id[credential.credential_id] = OnePasswordCredentialRefreshResult(+ vault_id=vault_id,+ item_id=item_id,+ status="skipped",+ reason="Credential moved while refresh was in progress.",+ )+ skipped += 1++ stale_ids = await app.DATABASE.credentials.set_onepassword_credentials_stale(+ organization_id,+ [(credential.credential_id, credential.folder_id) for credential, _vault_id, _item_id in missing_credentials],+ stale=True,+ )+ unstale_ids = await app.DATABASE.credentials.set_onepassword_credentials_stale(+ organization_id,+ [+ (credential.credential_id, credential.folder_id)+ for credential, _item, _vault_id, _item_id in unsupported_credentials+ ],+ stale=False,+ )+ stale = len(stale_ids)+ for credential, vault_id, item_id in missing_credentials:+ if credential.credential_id in stale_ids:+ results_by_id[credential.credential_id] = OnePasswordCredentialRefreshResult(+ vault_id=vault_id,+ item_id=item_id,+ status="stale",+ )+ else:+ results_by_id[credential.credential_id] = OnePasswordCredentialRefreshResult(+ vault_id=vault_id,+ item_id=item_id,+ status="skipped",+ reason="Credential moved while refresh was in progress.",+ )+ skipped += 1+ for credential, item, vault_id, item_id in unsupported_credentials:+ results_by_id[credential.credential_id] = OnePasswordCredentialRefreshResult(+ vault_id=vault_id,+ item_id=item_id,+ status="skipped",+ reason=(+ f"Unsupported 1Password category: {item.category.value}"+ if credential.credential_id in unstale_ids+ else "Credential moved while refresh was in progress."+ ),+ )+ skipped += 1+ return RefreshOnePasswordCredentialsResponse(+ refreshed=refreshed,+ stale=stale,+ skipped=skipped,+ results=[+ results_by_id[credential.credential_id]+ for credential in credentials+ if credential.credential_id in results_by_id+ ],+ )++@base_router.get("/credentials/bitwarden/items",response_model=BitwardenItemsResponse,@@ -4062,6 +4405,7 @@ def _convert_to_response(credential: Credential) -> CredentialResponse:credit card metadata, or secret values. See the moduledocstring for the full security invariant."""+ is_onepassword = credential.vault_type == CredentialVaultType.ONEPASSWORDif credential.credential_type == CredentialType.PASSWORD:credential_response = PasswordCredentialResponse(username=credential.username or credential.credential_id,@@ -4075,6 +4419,9 @@ def _convert_to_response(credential: Credential) -> CredentialResponse:credential_type=credential.credential_type,name=credential.name,vault_type=credential.vault_type,+ vault_id=credential.vault_id if is_onepassword else None,+ item_id=credential.item_id if is_onepassword else None,+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,browser_profile_id=credential.browser_profile_id,auto_profile_disabled=credential.auto_profile_disabled,pin_saved_session_ip=credential.pin_saved_session_ip,@@ -4098,6 +4445,9 @@ def _convert_to_response(credential: Credential) -> CredentialResponse:credential_type=credential.credential_type,name=credential.name,vault_type=credential.vault_type,+ vault_id=credential.vault_id if is_onepassword else None,+ item_id=credential.item_id if is_onepassword else None,+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,browser_profile_id=credential.browser_profile_id,auto_profile_disabled=credential.auto_profile_disabled,pin_saved_session_ip=credential.pin_saved_session_ip,@@ -4118,6 +4468,9 @@ def _convert_to_response(credential: Credential) -> CredentialResponse:credential_type=credential.credential_type,name=credential.name,vault_type=credential.vault_type,+ vault_id=credential.vault_id if is_onepassword else None,+ item_id=credential.item_id if is_onepassword else None,+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,browser_profile_id=credential.browser_profile_id,auto_profile_disabled=credential.auto_profile_disabled,pin_saved_session_ip=credential.pin_saved_session_ip,diff --git a/skyvern/forge/sdk/schemas/credentials.py b/skyvern/forge/sdk/schemas/credentials.pyindex 1e78fc0b2..969b2365c 100644--- a/skyvern/forge/sdk/schemas/credentials.py+++ b/skyvern/forge/sdk/schemas/credentials.py@@ -1,6 +1,6 @@from datetime import datetimefrom enum import StrEnum-from typing import Self+from typing import Literal, Selffrom fastapi import statusfrom pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator@@ -300,6 +300,11 @@ class CredentialResponse(BaseModel):default=None,description="Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom')",)+ vault_id: str | None = Field(default=None, description="1Password vault ID for linked credentials")+ item_id: str | None = Field(default=None, description="1Password item ID for linked credentials")+ upstream_missing_at: datetime | None = Field(+ default=None, description="When the linked 1Password item was last found missing upstream"+ )browser_profile_id: str | None = Field(default=None, description="Browser profile ID linked to this credential")auto_profile_disabled: bool | None = Field(default=None,@@ -359,6 +364,58 @@ class OnePasswordItemsResponse(BaseModel):source: OnePasswordTokenSource | None = None+ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT = 500+++class OnePasswordCredentialSelection(BaseModel):+ vault_id: str = Field(..., min_length=1)+ item_id: str = Field(..., min_length=1)+++class ImportOnePasswordCredentialsRequest(BaseModel):+ folder_id: str | None = Field(default=None, min_length=1)+ items: list[OnePasswordCredentialSelection] = Field(..., min_length=1)++ @field_validator("items")+ @classmethod+ def enforce_item_limit(cls, items: list[OnePasswordCredentialSelection]) -> list[OnePasswordCredentialSelection]:+ if len(items) > ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT:+ raise ValueError(+ f"Import at most {ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT} 1Password items per request; "+ "split the request into smaller batches"+ )+ return items+++class OnePasswordCredentialImportResult(BaseModel):+ vault_id: str+ item_id: str+ status: Literal["imported", "updated", "skipped"]+ reason: str | None = None+++class ImportOnePasswordCredentialsResponse(BaseModel):+ results: list[OnePasswordCredentialImportResult]+++class RefreshOnePasswordCredentialsRequest(BaseModel):+ folder_id: str | None = Field(default=None, min_length=1)+++class OnePasswordCredentialRefreshResult(BaseModel):+ vault_id: str+ item_id: str+ status: Literal["refreshed", "stale", "skipped"]+ reason: str | None = None+++class RefreshOnePasswordCredentialsResponse(BaseModel):+ refreshed: int+ stale: int+ skipped: int+ results: list[OnePasswordCredentialRefreshResult]++class BitwardenItemOverview(BaseModel):"""Response model for Bitwarden item metadata."""@@ -394,6 +451,9 @@ class Credential(BaseModel):vault_id: str | None = Field(default=None, description="ID of the credential's vault, when the provider requires it")+ upstream_missing_at: datetime | None = Field(+ default=None, description="When the linked 1Password item was last found missing upstream"+ )credential_type: CredentialType = Field(..., description="Type of the credential. Eg password, credit card, etc.")username: str | None = Field(..., description="For password credentials: the username")totp_type: TotpType = Field(diff --git a/skyvern/forge/sdk/services/route_authorization.py b/skyvern/forge/sdk/services/route_authorization.pyindex cf62336fc..5b43be99d 100644--- a/skyvern/forge/sdk/services/route_authorization.py+++ b/skyvern/forge/sdk/services/route_authorization.py@@ -145,8 +145,10 @@ ROUTE_ACTIONS: Mapping[str, str] = {"skyvern.forge.sdk.routes.credentials.get_onepassword_token_status": "vault_provider.status","skyvern.forge.sdk.routes.credentials.get_test_credential_status": "credential.list","skyvern.forge.sdk.routes.credentials.get_totp_codes": "credential.list",+ "skyvern.forge.sdk.routes.credentials.import_onepassword_credentials": "credential.create","skyvern.forge.sdk.routes.credentials.list_bitwarden_items": "vault_provider.list","skyvern.forge.sdk.routes.credentials.list_onepassword_items": "vault_provider.list",+ "skyvern.forge.sdk.routes.credentials.refresh_onepassword_credentials": "credential.update","skyvern.forge.sdk.routes.credentials.rename_credential": "credential.update","skyvern.forge.sdk.routes.credentials.send_totp_code": "credential.send","skyvern.forge.sdk.routes.credentials.test_credential": "credential.test",diff --git a/tests/unit/forge/sdk/db/test_credentials_repository.py b/tests/unit/forge/sdk/db/test_credentials_repository.pyindex 987a095ab..44f9c118f 100644--- a/tests/unit/forge/sdk/db/test_credentials_repository.py+++ b/tests/unit/forge/sdk/db/test_credentials_repository.py@@ -1,5 +1,6 @@import pytestimport pytest_asyncio+from sqlalchemy import selectfrom sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine@@ -89,3 +90,62 @@ async def test_vault_item_link_is_unique_per_organization_and_round_trips(repo_aawait create(ORG_B, "vault-1")await create(ORG_A, None)await create(ORG_A, None)+++async def test_onepassword_metadata_upsert_is_idempotent_and_stale_state_clears(repo_and_session) -> None:+ repo, session_factory = repo_and_session+ created, was_created = await repo.upsert_onepassword_credential_metadata(+ organization_id=ORG_A,+ vault_id="vault-1",+ item_id="item-1",+ name="Original title",+ credential_type=CredentialType.PASSWORD,+ tested_url="https://example.test/login",+ folder_id=None,+ created_by="user-1",+ )+ assert was_created+ assert created.vault_type == CredentialVaultType.ONEPASSWORD+ assert created.vault_id == "vault-1" and created.item_id == "item-1"++ updated, was_created = await repo.upsert_onepassword_credential_metadata(+ organization_id=ORG_A,+ vault_id="vault-1",+ item_id="item-1",+ name="Updated title",+ credential_type=CredentialType.CREDIT_CARD,+ tested_url="https://example.test/card",+ folder_id=None,+ created_by="user-2",+ )+ assert not was_created+ assert updated.credential_id == created.credential_id+ assert updated.name == "Updated title"+ assert updated.credential_type == CredentialType.CREDIT_CARD+ assert updated.created_by == "user-1"+ assert await repo.get_onepassword_credentials(ORG_A) == [updated]++ await repo.set_onepassword_credentials_stale(ORG_A, [(updated.credential_id, None)], stale=True)+ async with session_factory() as session:+ stale_at = await session.scalar(+ select(CredentialModel.upstream_missing_at).where(CredentialModel.credential_id == updated.credential_id)+ )+ assert stale_at is not None++ refreshed, was_created = await repo.upsert_onepassword_credential_metadata(+ organization_id=ORG_A,+ vault_id="vault-1",+ item_id="item-1",+ name="Restored title",+ credential_type=CredentialType.CREDIT_CARD,+ tested_url="https://example.test/card",+ folder_id=None,+ created_by="user-2",+ )+ assert not was_created+ async with session_factory() as session:+ stale_at = await session.scalar(+ select(CredentialModel.upstream_missing_at).where(CredentialModel.credential_id == refreshed.credential_id)+ )+ assert stale_at is None