Skip to content

Automate browser based workflows with AI

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.py
new file mode 100644
index 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.json
index 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.py
index 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.py
index 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, Sequence
from datetime import datetime, timezone
from 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 AsyncSession
from skyvern.forge.sdk.db._error_handling import db_operation
from skyvern.forge.sdk.db.base_repository import BaseRepository
+from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.db.exceptions import NotFoundError
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
@@ -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: str
diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.py
index 89d0496e4..a90239e10 100644
--- a/skyvern/forge/sdk/routes/credentials.py
+++ b/skyvern/forge/sdk/routes/credentials.py
@@ -43,6 +43,7 @@ import structlog
from fastapi import BackgroundTasks, Body, Depends, Header, HTTPException, Path, Query, Response, status
from onepassword.client import Client as OnePasswordClient
from onepassword.errors import DesktopSessionExpiredException, RateLimitExceededException
+from onepassword.types import Item
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
@@ -85,6 +86,7 @@ from skyvern.forge.sdk.routes.code_samples import (
from skyvern.forge.sdk.routes.routers import base_router, legacy_base_router
from skyvern.forge.sdk.routes.trigger_type import workflow_run_trigger_type_from_user_agent
from 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_identifier
from skyvern.utils.url_validators import validate_url
LOG = 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 module
docstring for the full security invariant.
"""
+ is_onepassword = credential.vault_type == CredentialVaultType.ONEPASSWORD
if credential.credential_type == CredentialType.PASSWORD:
credential_response = PasswordCredentialResponse(
username=credential.username or credential.credential_id,
@@ -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.py
index 1e78fc0b2..969b2365c 100644
--- a/skyvern/forge/sdk/schemas/credentials.py
+++ b/skyvern/forge/sdk/schemas/credentials.py
@@ -1,6 +1,6 @@
from datetime import datetime
from enum import StrEnum
-from typing import Self
+from typing import Literal, Self
from fastapi import status
from 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.py
index 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.py
index 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 pytest
import pytest_asyncio
+from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from 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_a
await 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