Skip to content

Automate browser based workflows with AI

Add 1Password credential import UI (#8953)

Aaron Perez4e681d04291b
diff --git a/skyvern-frontend/src/api/types.ts b/skyvern-frontend/src/api/types.ts
index 76eab0dda..337f7641f 100644
--- a/skyvern-frontend/src/api/types.ts
+++ b/skyvern-frontend/src/api/types.ts
@@ -280,6 +280,38 @@ export type OnePasswordItemsApiResponse = {
items: Array<OnePasswordItemApiResponse>;
};
+export const ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT = 500;
+
+export type OnePasswordCredentialImportRequest = {
+ folder_id?: string;
+ items: Array<{ vault_id: string; item_id: string }>;
+};
+
+export type OnePasswordCredentialImportResult = {
+ vault_id: string;
+ item_id: string;
+ status: "imported" | "updated" | "skipped";
+ reason?: string | null;
+};
+
+export type OnePasswordCredentialImportResponse = {
+ results: Array<OnePasswordCredentialImportResult>;
+};
+
+export type OnePasswordCredentialRefreshResult = {
+ vault_id: string;
+ item_id: string;
+ status: "refreshed" | "stale" | "skipped";
+ reason?: string | null;
+};
+
+export type OnePasswordCredentialRefreshResponse = {
+ refreshed: number;
+ stale: number;
+ skipped: number;
+ results: Array<OnePasswordCredentialRefreshResult>;
+};
+
export type BitwardenItemApiResponse = {
item_id: string;
title: string;
@@ -1125,6 +1157,17 @@ export type CredentialApiResponse = {
| SecretCredentialResponse;
credential_type: "password" | "credit_card" | "secret";
name: string;
+ vault_type?:
+ | "skyvern"
+ | "bitwarden"
+ | "azure_vault"
+ | "gcp"
+ | "custom"
+ | "onepassword"
+ | null;
+ vault_id?: string | null;
+ item_id?: string | null;
+ upstream_missing_at?: string | null;
browser_profile_id?: string | null;
auto_profile_disabled?: boolean | null;
pin_saved_session_ip?: boolean | null;
diff --git a/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.test.tsx b/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.test.tsx
new file mode 100644
index 000000000..f5c2eb3db
--- /dev/null
+++ b/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.test.tsx
@@ -0,0 +1,67 @@
+// @vitest-environment jsdom
+
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { getClient } from "@/api/AxiosClient";
+import { CredentialFolderSelector } from "./CredentialFolderSelector";
+
+vi.mock("@/api/AxiosClient", () => ({ getClient: vi.fn() }));
+vi.mock("@/hooks/useCredentialGetter", () => ({
+ useCredentialGetter: () => null,
+}));
+
+const mockedGetClient = vi.mocked(getClient);
+
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+});
+
+describe("CredentialFolderSelector selection mode", () => {
+ it("returns the chosen folder without assigning it to a credential", async () => {
+ const folder = {
+ folder_id: "folder-1",
+ organization_id: "org-1",
+ title: "Team folder",
+ description: null,
+ credential_count: 0,
+ created_at: "2026-10-18T00:00:00Z",
+ modified_at: "2026-10-18T00:00:00Z",
+ };
+ const get = vi.fn().mockResolvedValue({ data: [folder] });
+ mockedGetClient.mockResolvedValue({ get } as never);
+ const onFolderSelect = vi.fn();
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+
+ render(
+ <QueryClientProvider client={queryClient}>
+ <CredentialFolderSelector
+ currentFolderId={null}
+ onFolderSelect={onFolderSelect}
+ trigger={<button>Select target folder</button>}
+ />
+ </QueryClientProvider>,
+ );
+
+ fireEvent.click(
+ screen.getByRole("button", { name: "Select target folder" }),
+ );
+ fireEvent.click(await screen.findByRole("button", { name: "Team folder" }));
+
+ await waitFor(() => expect(onFolderSelect).toHaveBeenCalledWith(folder));
+ expect(get).toHaveBeenCalledWith(
+ "/credential_folders",
+ expect.objectContaining({ params: expect.any(URLSearchParams) }),
+ );
+ });
+});
diff --git a/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.tsx b/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.tsx
index 6170bad98..82a951cdd 100644
--- a/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.tsx
+++ b/skyvern-frontend/src/routes/credentials/CredentialFolderSelector.tsx
@@ -18,6 +18,7 @@ import { useInfiniteCredentialFoldersQuery } from "./hooks/useInfiniteCredential
import { useUpdateCredentialFolderAssignmentMutation } from "./hooks/useCredentialFolderMutations";
import { useDebounce } from "use-debounce";
import { Skeleton } from "@/components/ui/skeleton";
+import type { CredentialFolder } from "./types/credentialFolderTypes";
interface CredentialFolderSelectorProps {
credentialId?: string;
@@ -27,6 +28,7 @@ interface CredentialFolderSelectorProps {
bulkHasFolders?: boolean;
disabled?: boolean;
trigger?: React.ReactNode;
+ onFolderSelect?: (folder: CredentialFolder | null) => void;
}
function CredentialFolderSelector({
@@ -37,6 +39,7 @@ function CredentialFolderSelector({
bulkHasFolders = true,
disabled = false,
trigger,
+ onFolderSelect,
}: CredentialFolderSelectorProps) {
const [open, setOpen] = useState(false);
const [search, setSearch] = useState("");
@@ -61,6 +64,14 @@ function CredentialFolderSelector({
// or the bulk bar's Processing label, not in a hanging popover.
setOpen(false);
setSearch("");
+ if (onFolderSelect) {
+ onFolderSelect(
+ folderId
+ ? (folders.find((folder) => folder.folder_id === folderId) ?? null)
+ : null,
+ );
+ return;
+ }
if (isBulkMode && onBulkFolderSelect) {
await onBulkFolderSelect(folderId);
return;
@@ -110,7 +121,9 @@ function CredentialFolderSelector({
<h4 className="mb-2 text-sm font-medium">
{isBulkMode
? `Move ${bulkCount} credential${bulkCount === 1 ? "" : "s"} to folder`
- : "Move to folder"}
+ : onFolderSelect
+ ? "Choose target folder"
+ : "Move to folder"}
</h4>
<div className="relative">
<MagnifyingGlassIcon className="absolute left-2 top-1/2 h-4 w-4 -translate-y-1/2 text-slate-400" />
@@ -134,7 +147,9 @@ function CredentialFolderSelector({
)
}
>
- {(isBulkMode ? bulkHasFolders : Boolean(currentFolderId)) && (
+ {(isBulkMode
+ ? bulkHasFolders
+ : Boolean(currentFolderId) || Boolean(onFolderSelect)) && (
<button
onClick={() => handleFolderSelect(null)}
disabled={disabled || updateFolderMutation.isPending}
@@ -142,7 +157,9 @@ function CredentialFolderSelector({
>
<div className="flex items-center gap-2">
<Cross2Icon className="h-4 w-4 text-red-400" />
- <span>Remove from folder</span>
+ <span>
+ {onFolderSelect ? "No folder" : "Remove from folder"}
+ </span>
</div>
</button>
)}
diff --git a/skyvern-frontend/src/routes/credentials/CredentialItem.test.tsx b/skyvern-frontend/src/routes/credentials/CredentialItem.test.tsx
index 8853b5c3f..6452a6f73 100644
--- a/skyvern-frontend/src/routes/credentials/CredentialItem.test.tsx
+++ b/skyvern-frontend/src/routes/credentials/CredentialItem.test.tsx
@@ -240,3 +240,21 @@ describe("CredentialItem saved browser session", () => {
).toBeGreaterThan(0);
});
});
+
+describe("CredentialItem 1Password metadata", () => {
+ it("shows the 1Password badge and missing-upstream note", () => {
+ render(
+ <CredentialItem
+ credential={makePasswordCredential({
+ vault_type: "onepassword",
+ vault_id: "vault-1",
+ item_id: "item-1",
+ upstream_missing_at: "2026-10-18T12:00:00Z",
+ })}
+ />,
+ );
+
+ expect(screen.getByText("1Password")).toBeTruthy();
+ expect(screen.getByText("missing in 1Password")).toBeTruthy();
+ });
+});
diff --git a/skyvern-frontend/src/routes/credentials/CredentialItem.tsx b/skyvern-frontend/src/routes/credentials/CredentialItem.tsx
index 4f86a7c28..1b1f8042a 100644
--- a/skyvern-frontend/src/routes/credentials/CredentialItem.tsx
+++ b/skyvern-frontend/src/routes/credentials/CredentialItem.tsx
@@ -33,6 +33,7 @@ import { getHostname } from "@/util/getHostname";
import { CredentialsModal } from "./CredentialsModal";
import { credentialTypeToModalType } from "./useCredentialModalState";
import { SaveIcon } from "@/components/icons/SaveIcon";
+import { OnePasswordIcon } from "@/components/icons/OnePasswordIcon";
import { useCredentialTestStore } from "@/store/useCredentialTestStore";
import { useCredentialGetter } from "@/hooks/useCredentialGetter";
import { toast } from "@/components/ui/use-toast";
@@ -409,9 +410,23 @@ function CredentialItem({
</div>
)}
<div className="w-48 space-y-2">
- <p className="w-full truncate" title={credential.name}>
- {credential.name}
- </p>
+ <div className="flex min-w-0 items-center gap-2">
+ <p className="min-w-0 flex-1 truncate" title={credential.name}>
+ {credential.name}
+ </p>
+ {credential.vault_type === "onepassword" && (
+ <span className="inline-flex shrink-0 items-center gap-1 rounded border border-amber-500/20 bg-amber-500/10 px-1.5 py-0.5 text-[10px] text-amber-700 dark:text-amber-300">
+ <OnePasswordIcon className="size-3" />
+ 1Password
+ </span>
+ )}
+ </div>
+ {credential.vault_type === "onepassword" &&
+ credential.upstream_missing_at && (
+ <p className="text-xs text-amber-700 dark:text-amber-300">
+ missing in 1Password
+ </p>
+ )}
<p className="text-sm text-neutral-600 dark:text-slate-400">
{credential.credential_id}
</p>
diff --git a/skyvern-frontend/src/routes/credentials/ImportOnePasswordDialog.test.tsx b/skyvern-frontend/src/routes/credentials/ImportOnePasswordDialog.test.tsx
new file mode 100644
index 000000000..b368d7204
--- /dev/null
+++ b/skyvern-frontend/src/routes/credentials/ImportOnePasswordDialog.test.tsx
@@ -0,0 +1,339 @@
+// @vitest-environment jsdom
+
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { getClient } from "@/api/AxiosClient";
+import type {
+ CredentialApiResponse,
+ OnePasswordItemsApiResponse,
+} from "@/api/types";
+import { Button } from "@/components/ui/button";
+import { ImportOnePasswordDialog } from "./ImportOnePasswordDialog";
+
+vi.mock("@/api/AxiosClient", () => ({ getClient: vi.fn() }));
+vi.mock("@/hooks/useCredentialGetter", () => ({
+ useCredentialGetter: () => null,
+}));
+
+const mockedGetClient = vi.mocked(getClient);
+
+function makeImportedCredential(itemId: string): CredentialApiResponse {
+ return {
+ credential_id: `credential-${itemId}`,
+ credential_type: "password",
+ name: `Existing ${itemId}`,
+ vault_type: "onepassword",
+ vault_id: "vault-1",
+ item_id: itemId,
+ credential: {
+ username: "[email protected]",
+ totp_type: "none",
+ totp_identifier: null,
+ },
+ };
+}
+
+function renderDialog() {
+ const queryClient = new QueryClient({
+ defaultOptions: {
+ queries: { retry: false },
+ mutations: { retry: false },
+ },
+ });
+ return render(
+ <QueryClientProvider client={queryClient}>
+ <ImportOnePasswordDialog
+ trigger={<Button>Import from 1Password</Button>}
+ />
+ </QueryClientProvider>,
+ );
+}
+
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+});
+
+describe("ImportOnePasswordDialog", () => {
+ it("selects available items by vault and renders per-item import results", async () => {
+ const items: OnePasswordItemsApiResponse = {
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-existing",
+ title: "Existing login",
+ vault_id: "vault-1",
+ vault_name: "Team vault",
+ category: "LOGIN",
+ },
+ {
+ item_id: "item-new",
+ title: "New login",
+ vault_id: "vault-1",
+ vault_name: "Team vault",
+ category: "LOGIN",
+ },
+ {
+ item_id: "item-unsupported",
+ title: "Unsupported item",
+ vault_id: "vault-2",
+ vault_name: "Archive vault",
+ category: "DOCUMENT",
+ },
+ ],
+ };
+ const firstPage = Array.from({ length: 500 }, (_, index) =>
+ makeImportedCredential(`unrelated-${index}`),
+ );
+ const get = vi.fn(
+ async (path: string, options?: { params?: Record<string, unknown> }) => {
+ if (path === "/credentials/onepassword/items") {
+ return { data: items };
+ }
+ if (path === "/credentials") {
+ return {
+ data:
+ options?.params?.page === 1
+ ? firstPage
+ : [makeImportedCredential("item-existing")],
+ };
+ }
+ if (path === "/credential_folders") {
+ return {
+ data: [
+ {
+ folder_id: "folder-1",
+ organization_id: "org-1",
+ title: "Imported logins",
+ description: null,
+ credential_count: 0,
+ created_at: "2026-10-18T00:00:00Z",
+ modified_at: "2026-10-18T00:00:00Z",
+ },
+ ],
+ };
+ }
+ throw new Error(`Unexpected GET ${path}`);
+ },
+ );
+ const post = vi.fn().mockResolvedValue({
+ data: {
+ results: [
+ {
+ vault_id: "vault-1",
+ item_id: "item-new",
+ status: "imported",
+ reason: null,
+ },
+ {
+ vault_id: "vault-2",
+ item_id: "item-unsupported",
+ status: "skipped",
+ reason: "Unsupported 1Password category: DOCUMENT",
+ },
+ ],
+ },
+ });
+ mockedGetClient.mockResolvedValue({ get, post } as never);
+
+ renderDialog();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Import from 1Password" }),
+ );
+
+ const existingCheckbox = await screen.findByRole("checkbox", {
+ name: "Select Existing login",
+ });
+ expect((existingCheckbox as HTMLButtonElement).disabled).toBe(true);
+ expect(get).toHaveBeenCalledWith(
+ "/credentials",
+ expect.objectContaining({
+ params: expect.objectContaining({ page: 2, page_size: 500 }),
+ }),
+ );
+
+ fireEvent.click(
+ screen.getByRole("checkbox", { name: "Select all in Team vault" }),
+ );
+ fireEvent.click(
+ screen.getByRole("checkbox", { name: "Select Unsupported item" }),
+ );
+ expect(screen.getByRole("button", { name: "No folder" })).toBeTruthy();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Import selected items" }),
+ );
+
+ await waitFor(() => {
+ expect(post).toHaveBeenCalledWith("/credentials/onepassword/import", {
+ items: [
+ { vault_id: "vault-1", item_id: "item-new" },
+ { vault_id: "vault-2", item_id: "item-unsupported" },
+ ],
+ });
+ });
+ expect(await screen.findByText("Imported")).toBeTruthy();
+ expect(screen.getByText("Skipped")).toBeTruthy();
+ expect(
+ screen.getByText("Unsupported 1Password category: DOCUMENT"),
+ ).toBeTruthy();
+ expect(screen.getAllByText("New login").length).toBeGreaterThan(1);
+ });
+
+ it("retries a forbidden batch item by item and imports the remaining items", async () => {
+ const items: OnePasswordItemsApiResponse = {
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-hidden",
+ title: "Already linked item",
+ vault_id: "vault-1",
+ vault_name: "Team vault",
+ category: "LOGIN",
+ },
+ {
+ item_id: "item-new",
+ title: "New login",
+ vault_id: "vault-1",
+ vault_name: "Team vault",
+ category: "LOGIN",
+ },
+ ],
+ };
+ const get = vi.fn(async (path: string) => {
+ if (path === "/credentials/onepassword/items") {
+ return { data: items };
+ }
+ if (path === "/credentials") return { data: [] };
+ throw new Error(`Unexpected GET ${path}`);
+ });
+ const forbidden = {
+ isAxiosError: true,
+ response: { status: 403, data: { detail: "forbidden" } },
+ };
+ const post = vi.fn(
+ async (_path: string, request: { items: Array<{ item_id: string }> }) => {
+ if (
+ request.items.length > 1 ||
+ request.items[0]?.item_id === "item-hidden"
+ ) {
+ throw forbidden;
+ }
+ return {
+ data: {
+ results: [
+ {
+ vault_id: "vault-1",
+ item_id: "item-new",
+ status: "imported",
+ reason: null,
+ },
+ ],
+ },
+ };
+ },
+ );
+ mockedGetClient.mockResolvedValue({ get, post } as never);
+
+ renderDialog();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Import from 1Password" }),
+ );
+ fireEvent.click(
+ await screen.findByRole("checkbox", {
+ name: "Select Already linked item",
+ }),
+ );
+ fireEvent.click(screen.getByRole("checkbox", { name: "Select New login" }));
+ fireEvent.click(
+ screen.getByRole("button", { name: "Import selected items" }),
+ );
+
+ expect(await screen.findByText("Imported")).toBeTruthy();
+ expect(screen.getByText("Not permitted")).toBeTruthy();
+ expect(
+ screen.queryByText(/already linked in a folder you can't access/i),
+ ).toBeNull();
+ expect(post).toHaveBeenCalledTimes(3);
+ expect(post).toHaveBeenNthCalledWith(1, "/credentials/onepassword/import", {
+ items: [
+ { vault_id: "vault-1", item_id: "item-hidden" },
+ { vault_id: "vault-1", item_id: "item-new" },
+ ],
+ });
+ expect(post).toHaveBeenNthCalledWith(2, "/credentials/onepassword/import", {
+ items: [{ vault_id: "vault-1", item_id: "item-hidden" }],
+ });
+ expect(post).toHaveBeenNthCalledWith(3, "/credentials/onepassword/import", {
+ items: [{ vault_id: "vault-1", item_id: "item-new" }],
+ });
+ expect(screen.queryByRole("alert")).toBeNull();
+ });
+
+ it("shows a 403 and keeps the selection when every item retry is denied", async () => {
+ const get = vi.fn(async (path: string) => {
+ if (path === "/credentials/onepassword/items") {
+ return {
+ data: {
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-1",
+ title: "Example login",
+ vault_id: "vault-1",
+ vault_name: "Team vault",
+ category: "LOGIN",
+ },
+ ],
+ },
+ };
+ }
+ if (path === "/credentials") return { data: [] };
+ throw new Error(`Unexpected GET ${path}`);
+ });
+ const post = vi.fn().mockRejectedValue({
+ isAxiosError: true,
+ response: { status: 403, data: { detail: "forbidden" } },
+ });
+ mockedGetClient.mockResolvedValue({ get, post } as never);
+
+ renderDialog();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Import from 1Password" }),
+ );
+ fireEvent.click(
+ await screen.findByRole("checkbox", { name: "Select Example login" }),
+ );
+ fireEvent.click(
+ screen.getByRole("button", { name: "Import selected items" }),
+ );
+
+ expect((await screen.findByRole("alert")).textContent).toContain(
+ "You don’t have permission to import these 1Password items.",
+ );
+ expect(screen.getByText("1 selected")).toBeTruthy();
+ expect(
+ screen
+ .getByRole("checkbox", { name: "Select Example login" })
+ .getAttribute("aria-checked"),
+ ).toBe("true");
+ expect(post).toHaveBeenCalledTimes(2);
+ expect(post).toHaveBeenNthCalledWith(1, "/credentials/onepassword/import", {
+ items: [{ vault_id: "vault-1", item_id: "item-1" }],
+ });
+ expect(post).toHaveBeenNthCalledWith(2, "/credentials/onepassword/import", {
+ items: [{ vault_id: "vault-1", item_id: "item-1" }],
+ });
+ expect(screen.queryByText("Import results")).toBeNull();
+ });
+});
diff --git a/skyvern-frontend/src/routes/credentials/ImportOnePasswordDialog.tsx b/skyvern-frontend/src/routes/credentials/ImportOnePasswordDialog.tsx
new file mode 100644
index 000000000..e69065197
--- /dev/null
+++ b/skyvern-frontend/src/routes/credentials/ImportOnePasswordDialog.tsx
@@ -0,0 +1,412 @@
+import { useMemo, useState, type ReactElement } from "react";
+import { isAxiosError } from "axios";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { getClient } from "@/api/AxiosClient";
+import {
+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT,
+ type OnePasswordCredentialImportRequest,
+ type OnePasswordCredentialImportResponse,
+ type OnePasswordCredentialImportResult,
+} from "@/api/types";
+import { useCredentialGetter } from "@/hooks/useCredentialGetter";
+import { useOnePasswordItemsQuery } from "@/routes/workflows/hooks/useOnePasswordItemsQuery";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+ DialogTrigger,
+} from "@/components/ui/dialog";
+import { getCredentialErrorMessage } from "./authenticatorSaveError";
+import { CredentialFolderSelector } from "./CredentialFolderSelector";
+import { useImportedOnePasswordCredentialsQuery } from "./hooks/useImportedOnePasswordCredentialsQuery";
+import type { CredentialFolder } from "./types/credentialFolderTypes";
+
+type Props = {
+ trigger: ReactElement;
+};
+
+type VaultGroup = {
+ vaultId: string;
+ vaultName: string;
+ items: Array<{
+ item_id: string;
+ title: string;
+ category: string;
+ vault_id: string;
+ }>;
+};
+
+function itemKey(vaultId: string, itemId: string): string {
+ return JSON.stringify([vaultId, itemId]);
+}
+
+function resultLabel(
+ status: OnePasswordCredentialImportResult["status"],
+): string {
+ return status.charAt(0).toUpperCase() + status.slice(1);
+}
+
+function ImportOnePasswordDialog({ trigger }: Props) {
+ const [open, setOpen] = useState(false);
+ const [selectedKeys, setSelectedKeys] = useState<Set<string>>(new Set());
+ const [targetFolder, setTargetFolder] = useState<CredentialFolder | null>(
+ null,
+ );
+ const [results, setResults] =
+ useState<Array<OnePasswordCredentialImportResult> | null>(null);
+ const credentialGetter = useCredentialGetter();
+ const queryClient = useQueryClient();
+ const itemsQuery = useOnePasswordItemsQuery({ enabled: open });
+ const importedCredentialsQuery = useImportedOnePasswordCredentialsQuery(open);
+ const importedKeys = useMemo(
+ () =>
+ new Set(
+ (importedCredentialsQuery.data ?? [])
+ .filter((credential) => credential.vault_type === "onepassword")
+ .flatMap((credential) =>
+ credential.vault_id && credential.item_id
+ ? [itemKey(credential.vault_id, credential.item_id)]
+ : [],
+ ),
+ ),
+ [importedCredentialsQuery.data],
+ );
+ const items = useMemo(
+ () => itemsQuery.data?.items ?? [],
+ [itemsQuery.data?.items],
+ );
+ const groups = useMemo(() => {
+ const byVault = new Map<string, VaultGroup>();
+ for (const item of items) {
+ let group = byVault.get(item.vault_id);
+ if (!group) {
+ group = {
+ vaultId: item.vault_id,
+ vaultName: item.vault_name,
+ items: [],
+ };
+ byVault.set(item.vault_id, group);
+ }
+ group.items.push(item);
+ }
+ return [...byVault.values()];
+ }, [items]);
+ const canSelect =
+ !itemsQuery.isLoading &&
+ !itemsQuery.isError &&
+ !importedCredentialsQuery.isLoading &&
+ !importedCredentialsQuery.isError;
+ const selectedItems = items.filter(
+ (item) =>
+ selectedKeys.has(itemKey(item.vault_id, item.item_id)) &&
+ !importedKeys.has(itemKey(item.vault_id, item.item_id)),
+ );
+ const importMutation = useMutation({
+ mutationFn: async (request: OnePasswordCredentialImportRequest) => {
+ const client = await getClient(credentialGetter, "sans-api-v1");
+ const importItems = async (
+ items: OnePasswordCredentialImportRequest["items"],
+ ) =>
+ (
+ await client.post<OnePasswordCredentialImportResponse>(
+ "/credentials/onepassword/import",
+ { ...request, items },
+ )
+ ).data;
+
+ try {
+ return await importItems(request.items);
+ } catch (error) {
+ if (!isAxiosError(error) || error.response?.status !== 403) throw error;
+
+ const results: Array<OnePasswordCredentialImportResult> = [];
+ let deniedCount = 0;
+ for (const item of request.items) {
+ try {
+ results.push(...(await importItems([item])).results);
+ } catch (itemError) {
+ if (
+ !isAxiosError(itemError) ||
+ itemError.response?.status !== 403
+ ) {
+ throw itemError;
+ }
+ deniedCount += 1;
+ results.push({
+ ...item,
+ status: "skipped",
+ reason: "Not permitted",
+ });
+ }
+ }
+ if (deniedCount === request.items.length) throw error;
+ return { results };
+ }
+ },
+ onSuccess: ({ results: importResults }) => {
+ setResults(importResults);
+ setSelectedKeys(new Set());
+ void queryClient.invalidateQueries({ queryKey: ["credentials"] });
+ },
+ });
+ const resultNames = useMemo(
+ () =>
+ new Map(
+ items.map((item) => [itemKey(item.vault_id, item.item_id), item.title]),
+ ),
+ [items],
+ );
+
+ const handleOpenChange = (nextOpen: boolean) => {
+ setOpen(nextOpen);
+ if (nextOpen) {
+ setSelectedKeys(new Set());
+ setTargetFolder(null);
+ setResults(null);
+ importMutation.reset();
+ }
+ };
+
+ const handleImport = () => {
+ if (!selectedItems.length) return;
+ const request: OnePasswordCredentialImportRequest = {
+ ...(targetFolder ? { folder_id: targetFolder.folder_id } : {}),
+ items: selectedItems.map(({ vault_id, item_id }) => ({
+ vault_id,
+ item_id,
+ })),
+ };
+ importMutation.mutate(request);
+ };
+
+ const loading = itemsQuery.isLoading || importedCredentialsQuery.isLoading;
+ const loadError = itemsQuery.isError
+ ? "Couldn’t load 1Password items."
+ : importedCredentialsQuery.isError
+ ? "Couldn’t check which items are already imported."
+ : null;
+
+ return (
+ <Dialog open={open} onOpenChange={handleOpenChange}>
+ <DialogTrigger asChild>{trigger}</DialogTrigger>
+ <DialogContent className="ph-no-capture max-h-[85vh] overflow-y-auto sm:max-w-2xl">
+ <DialogHeader>
+ <DialogTitle>Import from 1Password</DialogTitle>
+ <DialogDescription>
+ Select items to add to your credentials. Imported items stay managed
+ in 1Password.
+ </DialogDescription>
+ </DialogHeader>
+
+ <div className="flex flex-wrap items-center justify-between gap-3">
+ <div className="min-w-0">
+ <p className="text-sm font-medium">Target folder</p>
+ <p className="text-xs text-muted-foreground">
+ {targetFolder?.title ?? "No folder"}
+ </p>
+ </div>
+ <CredentialFolderSelector
+ currentFolderId={targetFolder?.folder_id ?? null}
+ onFolderSelect={setTargetFolder}
+ trigger={
+ <Button variant="outline" size="sm">
+ {targetFolder?.title ?? "No folder"}
+ </Button>
+ }
+ />
+ </div>
+
+ {loading ? (
+ <p className="py-8 text-center text-sm text-muted-foreground">
+ Loading 1Password items…
+ </p>
+ ) : loadError ? (
+ <p role="alert" className="rounded-md bg-destructive/10 p-3 text-sm">
+ {loadError}
+ </p>
+ ) : itemsQuery.data?.source !== "organization" ? (
+ <p className="rounded-md bg-slate-elevation2 p-3 text-sm text-muted-foreground">
+ An organization 1Password account is required to import items.
+ </p>
+ ) : groups.length === 0 ? (
+ <p className="rounded-md bg-slate-elevation2 p-3 text-sm text-muted-foreground">
+ No items were found in readable 1Password vaults.
+ </p>
+ ) : (
+ <div className="max-h-[48vh] space-y-4 overflow-y-auto pr-1">
+ {groups.map((group) => {
+ const selectableItems = group.items.filter(
+ (item) =>
+ !importedKeys.has(itemKey(item.vault_id, item.item_id)),
+ );
+ const selectedCount = selectableItems.filter((item) =>
+ selectedKeys.has(itemKey(item.vault_id, item.item_id)),
+ ).length;
+ const allChecked =
+ selectedCount === selectableItems.length &&
+ selectableItems.length > 0;
+ const groupChecked = allChecked
+ ? true
+ : selectedCount > 0
+ ? "indeterminate"
+ : false;
+
+ return (
+ <section
+ key={group.vaultId}
+ className="rounded-lg border border-slate-700"
+ aria-label={group.vaultName}
+ >
+ <div className="flex items-center gap-3 border-b border-slate-700 px-4 py-3">
+ <Checkbox
+ aria-label={`Select all in ${group.vaultName}`}
+ checked={groupChecked}
+ disabled={
+ !canSelect ||
+ importMutation.isPending ||
+ selectableItems.length === 0 ||
+ (selectedKeys.size >=
+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT &&
+ selectedCount === 0)
+ }
+ onCheckedChange={(checked) =>
+ setSelectedKeys((current) => {
+ const next = new Set(current);
+ for (const item of selectableItems) {
+ const key = itemKey(item.vault_id, item.item_id);
+ if (checked === true) {
+ if (
+ next.size <
+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT
+ ) {
+ next.add(key);
+ }
+ } else {
+ next.delete(key);
+ }
+ }
+ return next;
+ })
+ }
+ />
+ <h3 className="text-sm font-medium">{group.vaultName}</h3>
+ <span className="ml-auto text-xs text-muted-foreground">
+ {group.items.length}{" "}
+ {group.items.length === 1 ? "item" : "items"}
+ </span>
+ </div>
+ <div className="divide-y divide-slate-700/70">
+ {group.items.map((item) => {
+ const key = itemKey(item.vault_id, item.item_id);
+ const isImported = importedKeys.has(key);
+ return (
+ <label
+ key={key}
+ className="flex cursor-pointer items-start gap-3 px-4 py-3 has-[:disabled]:cursor-not-allowed"
+ >
+ <Checkbox
+ aria-label={`Select ${item.title}`}
+ checked={selectedKeys.has(key)}
+ disabled={
+ !canSelect ||
+ isImported ||
+ importMutation.isPending ||
+ (selectedKeys.size >=
+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT &&
+ !selectedKeys.has(key))
+ }
+ onCheckedChange={(checked) =>
+ setSelectedKeys((current) => {
+ const next = new Set(current);
+ if (checked === true) next.add(key);
+ else next.delete(key);
+ return next;
+ })
+ }
+ />
+ <span className="min-w-0 flex-1">
+ <span className="block truncate text-sm font-medium">
+ {item.title}
+ </span>
+ <span className="text-xs text-muted-foreground">
+ {item.category}
+ {isImported ? " · Already imported" : ""}
+ </span>
+ </span>
+ </label>
+ );
+ })}
+ </div>
+ </section>
+ );
+ })}
+ </div>
+ )}
+
+ {importMutation.isError && (
+ <p role="alert" className="text-sm text-destructive">
+ {isAxiosError(importMutation.error) &&
+ importMutation.error.response?.status === 403
+ ? "You don’t have permission to import these 1Password items. Choose an accessible folder or contact your administrator."
+ : (getCredentialErrorMessage(importMutation.error) ??
+ "Failed to import 1Password items.")}
+ </p>
+ )}
+ {results && (
+ <section aria-label="Import results" className="space-y-2">
+ <h3 className="text-sm font-medium">Import results</h3>
+ <ul className="space-y-2">
+ {results.map((result) => (
+ <li
+ key={itemKey(result.vault_id, result.item_id)}
+ className="flex flex-wrap items-start gap-x-3 gap-y-1 rounded-md bg-slate-elevation2 px-3 py-2 text-sm"
+ >
+ <span className="font-medium">
+ {resultNames.get(
+ itemKey(result.vault_id, result.item_id),
+ ) ?? result.item_id}
+ </span>
+ <span className="text-muted-foreground">
+ {resultLabel(result.status)}
+ </span>
+ {result.reason && (
+ <span className="basis-full text-xs text-muted-foreground">
+ {result.reason}
+ </span>
+ )}
+ </li>
+ ))}
+ </ul>
+ </section>
+ )}
+
+ <DialogFooter className="flex-row items-center justify-between sm:justify-between">
+ <span className="text-xs text-muted-foreground">
+ {selectedItems.length} selected
+ {selectedItems.length === ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT &&
+ items.length > ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT &&
+ " · Maximum per import"}
+ </span>
+ <Button
+ onClick={handleImport}
+ disabled={
+ !canSelect ||
+ selectedItems.length === 0 ||
+ importMutation.isPending
+ }
+ >
+ {importMutation.isPending ? "Importing…" : "Import selected items"}
+ </Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+ );
+}
+
+export { ImportOnePasswordDialog };
diff --git a/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.test.tsx b/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.test.tsx
index 7941f974f..2f786deec 100644
--- a/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.test.tsx
+++ b/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.test.tsx
@@ -1,19 +1,54 @@
// @vitest-environment jsdom
-import { cleanup, render, screen } from "@testing-library/react";
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from "@testing-library/react";
import { MemoryRouter } from "react-router-dom";
+import type { ReactNode } from "react";
import { afterEach, describe, expect, it, vi } from "vitest";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import type { OnePasswordItemsApiResponse } from "@/api/types";
+import type {
+ CredentialApiResponse,
+ OnePasswordItemsApiResponse,
+} from "@/api/types";
+import { getClient } from "@/api/AxiosClient";
import { useOnePasswordItemsQuery } from "@/routes/workflows/hooks/useOnePasswordItemsQuery";
import CloudContext from "@/store/CloudContext";
import { OnePasswordCredentialsList } from "./OnePasswordCredentialsList";
+import { useImportedOnePasswordCredentialsQuery } from "./hooks/useImportedOnePasswordCredentialsQuery";
+vi.mock("@/api/AxiosClient", () => ({ getClient: vi.fn() }));
+vi.mock("@/hooks/useCredentialGetter", () => ({
+ useCredentialGetter: () => null,
+}));
vi.mock("@/routes/workflows/hooks/useOnePasswordItemsQuery", () => ({
useOnePasswordItemsQuery: vi.fn(),
}));
+vi.mock("./hooks/useImportedOnePasswordCredentialsQuery", () => ({
+ useImportedOnePasswordCredentialsQuery: vi.fn(),
+}));
+vi.mock("./ImportOnePasswordDialog", () => ({
+ ImportOnePasswordDialog: ({ trigger }: { trigger: ReactNode }) => trigger,
+}));
const mockedUseOnePasswordItemsQuery = vi.mocked(useOnePasswordItemsQuery);
+const mockedUseImportedCredentialsQuery = vi.mocked(
+ useImportedOnePasswordCredentialsQuery,
+);
+const mockedGetClient = vi.mocked(getClient);
+
+function mockCredentials(data: CredentialApiResponse[] = []) {
+ mockedUseImportedCredentialsQuery.mockReturnValue({
+ data,
+ isLoading: false,
+ isError: false,
+ } as ReturnType<typeof useImportedOnePasswordCredentialsQuery>);
+}
function mockItems(data: OnePasswordItemsApiResponse) {
mockedUseOnePasswordItemsQuery.mockReturnValue({
@@ -21,6 +56,7 @@ function mockItems(data: OnePasswordItemsApiResponse) {
isLoading: false,
isError: false,
} as ReturnType<typeof useOnePasswordItemsQuery>);
+ mockCredentials();
}
function mockNonPasswordItems() {
@@ -39,13 +75,38 @@ function mockNonPasswordItems() {
});
}
+function importedCredential(
+ index: number,
+ folderId: string | null = null,
+): CredentialApiResponse {
+ return {
+ credential_id: `credential-${index}`,
+ credential_type: "password",
+ name: `Credential ${index}`,
+ vault_type: "onepassword",
+ vault_id: "vault-1",
+ item_id: `item-${index}`,
+ folder_id: folderId,
+ credential: {
+ username: "[email protected]",
+ totp_type: "none",
+ totp_identifier: null,
+ },
+ };
+}
+
function renderList(props: { search?: string } = {}, isCloud = false) {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+ });
return render(
- <CloudContext.Provider value={isCloud}>
- <MemoryRouter>
- <OnePasswordCredentialsList {...props} />
- </MemoryRouter>
- </CloudContext.Provider>,
+ <QueryClientProvider client={queryClient}>
+ <CloudContext.Provider value={isCloud}>
+ <MemoryRouter>
+ <OnePasswordCredentialsList {...props} />
+ </MemoryRouter>
+ </CloudContext.Provider>
+ </QueryClientProvider>,
);
}
@@ -128,4 +189,267 @@ describe("OnePasswordCredentialsList empty states", () => {
screen.queryByRole("link", { name: "1Password integration settings" }),
).toBeNull();
});
+
+ it("offers import from the connected-but-empty state when upstream items exist", () => {
+ mockItems({
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-1",
+ title: "Example card",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "CREDIT_CARD",
+ },
+ ],
+ });
+
+ renderList();
+
+ expect(
+ screen.getByText(/no login or password items were returned/i),
+ ).toBeTruthy();
+ expect(
+ screen.getByRole("button", { name: "Import from 1Password" }),
+ ).toBeTruthy();
+ });
+
+ it("keeps import available for unimported non-password items", () => {
+ mockItems({
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-imported",
+ title: "Imported card",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "CREDIT_CARD",
+ },
+ {
+ item_id: "item-new",
+ title: "New card",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "CREDIT_CARD",
+ },
+ ],
+ });
+ mockCredentials([{ ...importedCredential(1), item_id: "item-imported" }]);
+
+ renderList();
+
+ expect(
+ screen.getByRole("button", { name: "Import from 1Password" }),
+ ).toBeTruthy();
+ });
+
+ it("refreshes imported 1Password credentials from the section action", async () => {
+ const post = vi.fn().mockResolvedValue({
+ data: {
+ refreshed: 2,
+ stale: 1,
+ skipped: 1,
+ results: [
+ {
+ vault_id: "vault-1",
+ item_id: "item-1",
+ status: "refreshed",
+ },
+ {
+ vault_id: "vault-1",
+ item_id: "item-2",
+ status: "stale",
+ },
+ {
+ vault_id: "vault-1",
+ item_id: "item-3",
+ status: "skipped",
+ reason: "Credential moved while refresh was in progress.",
+ },
+ ],
+ },
+ });
+ mockedGetClient.mockResolvedValue({ post } as never);
+ mockItems({
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-1",
+ title: "Example login",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "LOGIN",
+ },
+ ],
+ });
+ mockCredentials([
+ {
+ credential_id: "cred-1",
+ credential_type: "password",
+ name: "Example login",
+ vault_type: "onepassword",
+ vault_id: "vault-1",
+ item_id: "item-1",
+ credential: {
+ username: "[email protected]",
+ totp_type: "none",
+ totp_identifier: null,
+ },
+ },
+ ]);
+
+ renderList();
+
+ fireEvent.click(
+ screen.getByRole("button", { name: "Refresh from 1Password" }),
+ );
+
+ await waitFor(() =>
+ expect(post).toHaveBeenCalledWith("/credentials/onepassword/refresh", {
+ folder_id: null,
+ }),
+ );
+ expect(
+ await screen.findByText(/2 refreshed.*1 missing.*1 skipped/i),
+ ).toBeTruthy();
+ });
+
+ it("refreshes more than 500 credentials with one request per folder", async () => {
+ const post = vi.fn().mockResolvedValue({
+ data: { refreshed: 250, stale: 0, skipped: 0, results: [] },
+ });
+ mockedGetClient.mockResolvedValue({ post } as never);
+ mockItems({
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-1",
+ title: "Example login",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "LOGIN",
+ },
+ ],
+ });
+ mockCredentials([
+ ...Array.from({ length: 250 }, (_, index) =>
+ importedCredential(index, "folder-1"),
+ ),
+ ...Array.from({ length: 251 }, (_, index) =>
+ importedCredential(index + 250),
+ ),
+ ]);
+
+ renderList();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Refresh from 1Password" }),
+ );
+
+ await waitFor(() => expect(post).toHaveBeenCalledTimes(2));
+ expect(post).toHaveBeenNthCalledWith(
+ 1,
+ "/credentials/onepassword/refresh",
+ {
+ folder_id: "folder-1",
+ },
+ );
+ expect(post).toHaveBeenNthCalledWith(
+ 2,
+ "/credentials/onepassword/refresh",
+ {
+ folder_id: null,
+ },
+ );
+ });
+
+ it("does not send a refresh batch larger than the endpoint limit", async () => {
+ const post = vi.fn();
+ mockedGetClient.mockResolvedValue({ post } as never);
+ mockItems({
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-1",
+ title: "Example login",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "LOGIN",
+ },
+ ],
+ });
+ mockCredentials(
+ Array.from({ length: 501 }, (_, index) =>
+ importedCredential(index, "large-folder"),
+ ),
+ );
+
+ renderList();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Refresh from 1Password" }),
+ );
+
+ await waitFor(() =>
+ expect(screen.getByRole("alert").textContent).toMatch(/more than 500/i),
+ );
+ expect(post).not.toHaveBeenCalled();
+ });
+
+ it("continues refreshing other folders after a folder returns 403", async () => {
+ const post = vi
+ .fn()
+ .mockRejectedValueOnce({
+ isAxiosError: true,
+ response: { status: 403, data: { detail: "forbidden" } },
+ })
+ .mockResolvedValueOnce({
+ data: {
+ refreshed: 1,
+ stale: 0,
+ skipped: 0,
+ results: [
+ {
+ vault_id: "vault-1",
+ item_id: "item-2",
+ status: "refreshed",
+ },
+ ],
+ },
+ });
+ mockedGetClient.mockResolvedValue({ post } as never);
+ mockItems({
+ configured: true,
+ source: "organization",
+ items: [
+ {
+ item_id: "item-1",
+ title: "Example login",
+ vault_id: "vault-1",
+ vault_name: "Example vault",
+ category: "LOGIN",
+ },
+ ],
+ });
+ mockCredentials([
+ importedCredential(1, "restricted-folder"),
+ importedCredential(2, "accessible-folder"),
+ ]);
+
+ renderList();
+ fireEvent.click(
+ screen.getByRole("button", { name: "Refresh from 1Password" }),
+ );
+
+ await waitFor(() => expect(post).toHaveBeenCalledTimes(2));
+ expect(
+ await screen.findByText(
+ /1 refreshed.*some folders could not be refreshed/i,
+ ),
+ ).toBeTruthy();
+ expect(screen.getByRole("alert").textContent).toMatch(/access/i);
+ });
});
diff --git a/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.tsx b/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.tsx
index 8b5cbd501..7fca156b4 100644
--- a/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.tsx
+++ b/skyvern-frontend/src/routes/credentials/OnePasswordCredentialsList.tsx
@@ -1,9 +1,21 @@
import { OnePasswordIcon } from "@/components/icons/OnePasswordIcon";
+import { isAxiosError } from "axios";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { getClient } from "@/api/AxiosClient";
+import {
+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT,
+ type OnePasswordCredentialRefreshResponse,
+} from "@/api/types";
+import { useCredentialGetter } from "@/hooks/useCredentialGetter";
+import { Button } from "@/components/ui/button";
import CloudContext from "@/store/CloudContext";
import { getHostname } from "@/util/getHostname";
+import { ReloadIcon } from "@radix-ui/react-icons";
import { useOnePasswordItemsQuery } from "@/routes/workflows/hooks/useOnePasswordItemsQuery";
-import { useContext, useMemo } from "react";
+import { useContext, useMemo, useState } from "react";
import { Link } from "react-router-dom";
+import { ImportOnePasswordDialog } from "./ImportOnePasswordDialog";
+import { useImportedOnePasswordCredentialsQuery } from "./hooks/useImportedOnePasswordCredentialsQuery";
import { isOnePasswordItemOfType } from "./onePasswordItems";
type Props = {
@@ -14,6 +26,98 @@ type Props = {
function OnePasswordCredentialsList({ search, folderId }: Props) {
const isCloud = useContext(CloudContext);
const { data, isLoading, isError } = useOnePasswordItemsQuery();
+ const {
+ data: importedCredentials = [],
+ isLoading: isLoadingImported,
+ isError: isErrorImported,
+ } = useImportedOnePasswordCredentialsQuery(!folderId);
+ const credentialGetter = useCredentialGetter();
+ const queryClient = useQueryClient();
+ const [refreshMessage, setRefreshMessage] = useState<string | null>(null);
+ const [refreshHasErrors, setRefreshHasErrors] = useState(false);
+ const refreshMutation = useMutation({
+ mutationFn: async () => {
+ const client = await getClient(credentialGetter, "sans-api-v1");
+ const countsByFolder = new Map<string | null, number>();
+ for (const credential of importedCredentials) {
+ const folderId = credential.folder_id ?? null;
+ countsByFolder.set(folderId, (countsByFolder.get(folderId) ?? 0) + 1);
+ }
+
+ const outcomes = await Promise.all(
+ [...countsByFolder].map(async ([folderId, count]) => {
+ // shortcut: same-folder batches above 500 are skipped, upgrade when refresh accepts item IDs.
+ if (count > ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT) {
+ return { errorStatus: 400 };
+ }
+ try {
+ const response =
+ await client.post<OnePasswordCredentialRefreshResponse>(
+ "/credentials/onepassword/refresh",
+ { folder_id: folderId },
+ );
+ return { data: response.data };
+ } catch (error) {
+ return {
+ errorStatus: isAxiosError(error)
+ ? error.response?.status
+ : undefined,
+ };
+ }
+ }),
+ );
+ const responses = outcomes.flatMap((outcome) =>
+ "data" in outcome && outcome.data ? [outcome.data] : [],
+ );
+ const errors = outcomes.flatMap((outcome) =>
+ "errorStatus" in outcome ? [outcome.errorStatus] : [],
+ );
+ const results = responses.flatMap((response) => response.results);
+
+ return {
+ response: {
+ refreshed: responses.reduce(
+ (total, response) => total + response.refreshed,
+ 0,
+ ),
+ stale: responses.reduce(
+ (total, response) => total + response.stale,
+ 0,
+ ),
+ skipped: responses.reduce(
+ (total, response) => total + response.skipped,
+ 0,
+ ),
+ results,
+ },
+ errors,
+ successfulBatches: responses.length,
+ };
+ },
+ onSuccess: ({ response, errors, successfulBatches }) => {
+ const errorMessages = [
+ errors.includes(403) &&
+ "Some folders could not be refreshed because you don’t have access.",
+ errors.includes(400) &&
+ "Some folders could not be refreshed because they contain more than 500 linked credentials.",
+ errors.some((status) => status !== 400 && status !== 403) &&
+ "Some folders could not be refreshed.",
+ ].filter(Boolean);
+ setRefreshMessage(
+ `${response.refreshed} refreshed, ${response.stale} missing, ${response.skipped} skipped.${
+ errorMessages.length ? ` ${errorMessages.join(" ")}` : ""
+ }`,
+ );
+ setRefreshHasErrors(errors.length > 0);
+ if (successfulBatches > 0) {
+ void queryClient.invalidateQueries({ queryKey: ["credentials"] });
+ }
+ },
+ onError: () => {
+ setRefreshHasErrors(true);
+ setRefreshMessage("Couldn’t refresh 1Password credentials.");
+ },
+ });
const normalizedSearch = search?.trim().toLowerCase() ?? "";
const passwordItems = useMemo(
@@ -32,16 +136,73 @@ function OnePasswordCredentialsList({ search, folderId }: Props) {
),
[passwordItems, normalizedSearch],
);
+ const importedKeys = useMemo(
+ () =>
+ new Set(
+ importedCredentials.flatMap((credential) =>
+ credential.vault_id && credential.item_id
+ ? [JSON.stringify([credential.vault_id, credential.item_id])]
+ : [],
+ ),
+ ),
+ [importedCredentials],
+ );
+ const hasOrganizationAccount =
+ data?.configured && data.source === "organization";
+ const hasImportableItems = (data?.items ?? []).some(
+ (item) => !importedKeys.has(JSON.stringify([item.vault_id, item.item_id])),
+ );
+ const canImport =
+ hasOrganizationAccount &&
+ !isLoadingImported &&
+ !isErrorImported &&
+ hasImportableItems;
+ const canRefresh = hasOrganizationAccount && importedCredentials.length > 0;
+ const showHeaderImport = canImport && passwordItems.length > 0;
const header = (
- <div className="flex items-center gap-2">
- <OnePasswordIcon className="size-5 shrink-0" />
- <div className="min-w-0 space-y-1">
- <p className="text-sm font-medium">1Password</p>
- <p className="text-sm text-neutral-600 dark:text-slate-400">
- Read-only — managed in your 1Password account
- </p>
+ <div className="flex flex-wrap items-center justify-between gap-3">
+ <div className="flex min-w-0 items-center gap-2">
+ <OnePasswordIcon className="size-5 shrink-0" />
+ <div className="min-w-0 space-y-1">
+ <p className="text-sm font-medium">1Password</p>
+ <p className="text-sm text-neutral-600 dark:text-slate-400">
+ Read-only — managed in your 1Password account
+ </p>
+ </div>
</div>
+ {showHeaderImport || canRefresh ? (
+ <div className="flex flex-wrap items-center gap-2">
+ {showHeaderImport && (
+ <ImportOnePasswordDialog
+ trigger={
+ <Button variant="secondary" size="sm">
+ Import from 1Password
+ </Button>
+ }
+ />
+ )}
+ {canRefresh && (
+ <Button
+ variant="outline"
+ size="sm"
+ disabled={refreshMutation.isPending}
+ onClick={() => {
+ setRefreshMessage(null);
+ setRefreshHasErrors(false);
+ refreshMutation.mutate();
+ }}
+ >
+ <ReloadIcon
+ className={`mr-2 size-3.5 ${refreshMutation.isPending ? "animate-spin" : ""}`}
+ />
+ {refreshMutation.isPending
+ ? "Refreshing…"
+ : "Refresh from 1Password"}
+ </Button>
+ )}
+ </div>
+ ) : null}
</div>
);
@@ -80,19 +241,40 @@ function OnePasswordCredentialsList({ search, folderId }: Props) {
return (
<div className="space-y-4">
{header}
- <p className="rounded-lg bg-slate-elevation2 p-4 text-sm text-neutral-600 dark:text-slate-400">
- No login or password items were returned from readable 1Password
- vaults. Check this service account&apos;s vault access. If those
- vaults contain no login or password items, add one or check its token
- in{" "}
- <Link
- className="font-medium text-blue-600 underline underline-offset-2 dark:text-blue-400"
- to={isCloud ? "/integrations?query=1Password" : "/settings"}
+ {refreshMessage && (
+ <p
+ role={refreshHasErrors ? "alert" : "status"}
+ className="text-sm text-muted-foreground"
>
- 1Password integration settings
- </Link>
- .
- </p>
+ {refreshMessage}
+ </p>
+ )}
+ <div className="rounded-lg bg-slate-elevation2 p-4 text-sm text-neutral-600 dark:text-slate-400">
+ <p>
+ No login or password items were returned from readable 1Password
+ vaults. Check this service account&apos;s vault access. If those
+ vaults contain no login or password items, add one or check its
+ token in{" "}
+ <Link
+ className="font-medium text-blue-600 underline underline-offset-2 dark:text-blue-400"
+ to={isCloud ? "/integrations?query=1Password" : "/settings"}
+ >
+ 1Password integration settings
+ </Link>
+ .
+ </p>
+ {canImport && (
+ <div className="mt-3">
+ <ImportOnePasswordDialog
+ trigger={
+ <Button variant="secondary" size="sm">
+ Import from 1Password
+ </Button>
+ }
+ />
+ </div>
+ )}
+ </div>
</div>
);
}
@@ -104,6 +286,14 @@ function OnePasswordCredentialsList({ search, folderId }: Props) {
return (
<div className="space-y-4">
{header}
+ {refreshMessage && (
+ <p
+ role={refreshHasErrors ? "alert" : "status"}
+ className="text-sm text-muted-foreground"
+ >
+ {refreshMessage}
+ </p>
+ )}
<div className="space-y-5">
{filteredItems.map((item) => (
<div
diff --git a/skyvern-frontend/src/routes/credentials/hooks/useImportedOnePasswordCredentialsQuery.ts b/skyvern-frontend/src/routes/credentials/hooks/useImportedOnePasswordCredentialsQuery.ts
new file mode 100644
index 000000000..a030b5214
--- /dev/null
+++ b/skyvern-frontend/src/routes/credentials/hooks/useImportedOnePasswordCredentialsQuery.ts
@@ -0,0 +1,39 @@
+import { getClient } from "@/api/AxiosClient";
+import {
+ ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT,
+ type CredentialApiResponse,
+} from "@/api/types";
+import { useCredentialGetter } from "@/hooks/useCredentialGetter";
+import { useQuery } from "@tanstack/react-query";
+
+function useImportedOnePasswordCredentialsQuery(enabled = true) {
+ const credentialGetter = useCredentialGetter();
+
+ return useQuery<Array<CredentialApiResponse>>({
+ queryKey: ["credentials", "onepassword-imported"],
+ queryFn: async () => {
+ const client = await getClient(credentialGetter);
+ const credentials: Array<CredentialApiResponse> = [];
+
+ for (let page = 1; ; page += 1) {
+ const response = await client.get<Array<CredentialApiResponse>>(
+ "/credentials",
+ {
+ params: {
+ page,
+ page_size: ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT,
+ vault_type: "onepassword",
+ },
+ },
+ );
+ credentials.push(...response.data);
+ if (response.data.length < ONEPASSWORD_CREDENTIALS_REQUEST_LIMIT) {
+ return credentials;
+ }
+ }
+ },
+ enabled,
+ });
+}
+
+export { useImportedOnePasswordCredentialsQuery };