Skip to content

Automate browser based workflows with AI

Expose 1Password and Bitwarden MCP endpoints (#7945)

Suchintand95ee2b3a3e7
diff --git a/skyvern-frontend/src/components/BrowserStream.test.tsx b/skyvern-frontend/src/components/BrowserStream.test.tsx
index da0d75fa6..4a6338b90 100644
--- a/skyvern-frontend/src/components/BrowserStream.test.tsx
+++ b/skyvern-frontend/src/components/BrowserStream.test.tsx
@@ -101,6 +101,7 @@ const mocks = vi.hoisted(() => {
rfbInstances,
recordingStore,
settingsStore,
+ toast: vi.fn(),
};
});
@@ -125,6 +126,10 @@ vi.mock("@/store/SettingsStore", () => ({
useSettingsStore: () => mocks.settingsStore,
}));
+vi.mock("@/components/ui/use-toast", () => ({
+ toast: mocks.toast,
+}));
+
vi.mock("@/store/useRecordingStore", () => {
// Honor the selector: BrowserStream reads slices (e.g. state.isRecording) via
// useRecordingStore(selector). Ignoring the selector and returning the whole
@@ -203,25 +208,94 @@ describe("BrowserStream", () => {
afterEach(() => {
cleanup();
+ vi.restoreAllMocks();
vi.clearAllMocks();
mocks.rfbInstances.length = 0;
});
- it("supports VNC paste after taking control of a browser session stream", async () => {
+ it("releases and restores held left Cmd around VNC paste", async () => {
const { container } = renderBrowserStream();
- const takeControlButton = await screen.findByRole("button", {
- name: /take control/i,
- });
+ const takeControlButton = await screen.findByRole(
+ "button",
+ { name: /take control/i },
+ { timeout: 10000 },
+ );
const stream = container.querySelector(".browser-stream");
+ const canvas = container.querySelector("canvas");
expect(stream).toBeInstanceOf(HTMLElement);
expect(mocks.rfbInstances).toHaveLength(1);
- fireEvent.keyDown(stream!, { ctrlKey: true, key: "v" });
+ fireEvent.keyDown(stream!, { key: "v", metaKey: true });
expect(mocks.rfbInstances[0]?.clipboardPasteFrom).not.toHaveBeenCalled();
fireEvent.click(takeControlButton);
- fireEvent.keyDown(stream!, { ctrlKey: true, key: "v" });
+ fireEvent.keyDown(canvas!, { key: "Meta", code: "MetaLeft" });
+ fireEvent.keyDown(stream!, { key: "v", metaKey: true });
+
+ await waitFor(() => {
+ expect(mocks.rfbInstances[0]?.clipboardPasteFrom).toHaveBeenCalledWith(
+ "https://example.test",
+ );
+ });
+ await waitFor(() => {
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenCalledTimes(6);
+ });
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 1,
+ 0xffe9,
+ "MetaLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 2,
+ 0xffe3,
+ "ControlLeft",
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 3,
+ 0x0076,
+ "KeyV",
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 4,
+ 0x0076,
+ "KeyV",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 5,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 6,
+ 0xffe9,
+ "MetaLeft",
+ true,
+ );
+ });
+
+ it("clears a held Cmd side when Meta is released elsewhere in the window", async () => {
+ const { container } = renderBrowserStream();
+ const takeControlButton = await screen.findByRole(
+ "button",
+ { name: /take control/i },
+ { timeout: 10000 },
+ );
+ const stream = container.querySelector(".browser-stream");
+ const canvas = container.querySelector("canvas");
+
+ expect(stream).toBeInstanceOf(HTMLElement);
+ expect(mocks.rfbInstances).toHaveLength(1);
+
+ fireEvent.click(takeControlButton);
+ fireEvent.keyDown(canvas!, { key: "Meta", code: "MetaLeft" });
+ fireEvent.keyUp(window, { key: "Meta", code: "MetaLeft" });
+ fireEvent.keyDown(stream!, { key: "v", metaKey: true });
await waitFor(() => {
expect(mocks.rfbInstances[0]?.clipboardPasteFrom).toHaveBeenCalledWith(
@@ -229,8 +303,186 @@ describe("BrowserStream", () => {
);
});
await waitFor(() => {
- expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenCalledTimes(4);
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenCalledTimes(8);
});
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 1,
+ 0xffe9,
+ "AltLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 2,
+ 0xffea,
+ "AltRight",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 3,
+ 0xffeb,
+ "MetaLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 4,
+ 0xffec,
+ "MetaRight",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 5,
+ 0xffe3,
+ "ControlLeft",
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 6,
+ 0x0076,
+ "KeyV",
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 7,
+ 0x0076,
+ "KeyV",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 8,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).not.toHaveBeenCalledWith(
+ 0xffe9,
+ "MetaLeft",
+ true,
+ );
+ });
+
+ it("does not restore a Cmd side whose keydown noVNC never received", async () => {
+ const { container } = renderBrowserStream();
+ const takeControlButton = await screen.findByRole(
+ "button",
+ { name: /take control/i },
+ { timeout: 10000 },
+ );
+ const stream = container.querySelector(".browser-stream");
+
+ expect(stream).toBeInstanceOf(HTMLElement);
+ expect(mocks.rfbInstances).toHaveLength(1);
+
+ fireEvent.click(takeControlButton);
+ fireEvent.keyDown(stream!, { key: "Meta", code: "MetaLeft" });
+ fireEvent.keyDown(stream!, { key: "v", metaKey: true });
+
+ await waitFor(() => {
+ expect(mocks.rfbInstances[0]?.clipboardPasteFrom).toHaveBeenCalledWith(
+ "https://example.test",
+ );
+ });
+ await waitFor(() => {
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenCalledTimes(8);
+ });
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 1,
+ 0xffe9,
+ "AltLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 2,
+ 0xffea,
+ "AltRight",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 3,
+ 0xffeb,
+ "MetaLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 4,
+ 0xffec,
+ "MetaRight",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 5,
+ 0xffe3,
+ "ControlLeft",
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 6,
+ 0x0076,
+ "KeyV",
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 7,
+ 0x0076,
+ "KeyV",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).toHaveBeenNthCalledWith(
+ 8,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).not.toHaveBeenCalledWith(
+ 0xffe9,
+ expect.any(String),
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).not.toHaveBeenCalledWith(
+ 0xffea,
+ expect.any(String),
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).not.toHaveBeenCalledWith(
+ 0xffeb,
+ expect.any(String),
+ true,
+ );
+ expect(mocks.rfbInstances[0]?.sendKey).not.toHaveBeenCalledWith(
+ 0xffec,
+ expect.any(String),
+ true,
+ );
+ });
+
+ it("shows a destructive toast when browser clipboard access fails", async () => {
+ const error = new Error("denied");
+ vi.mocked(navigator.clipboard.readText).mockRejectedValueOnce(error);
+ const consoleError = vi
+ .spyOn(console, "error")
+ .mockImplementation(() => {});
+ const { container } = renderBrowserStream();
+ const takeControlButton = await screen.findByRole(
+ "button",
+ { name: /take control/i },
+ { timeout: 10000 },
+ );
+ const stream = container.querySelector(".browser-stream");
+
+ fireEvent.click(takeControlButton);
+ fireEvent.keyDown(stream!, { key: "v", metaKey: true });
+
+ await waitFor(() => {
+ expect(mocks.toast).toHaveBeenCalledWith({
+ title: "Paste failed",
+ description:
+ "Skyvern couldn't read your clipboard. Allow clipboard access for this site and try again.",
+ variant: "destructive",
+ });
+ });
+ expect(mocks.toast).toHaveBeenCalledTimes(1);
+ expect(mocks.rfbInstances[0]?.clipboardPasteFrom).not.toHaveBeenCalled();
+ expect(mocks.rfbInstances[0]?.sendKey).not.toHaveBeenCalled();
+ expect(consoleError).toHaveBeenCalledTimes(1);
});
it("notifies activity after a VNC framebuffer update completes", async () => {
diff --git a/skyvern-frontend/src/components/BrowserStream.tsx b/skyvern-frontend/src/components/BrowserStream.tsx
index cac5a587d..162a0b452 100644
--- a/skyvern-frontend/src/components/BrowserStream.tsx
+++ b/skyvern-frontend/src/components/BrowserStream.tsx
@@ -40,7 +40,10 @@ import {
StreamStatusPanel,
type StreamDiagnostic,
} from "@/routes/streaming/StreamDiagnostics";
-import { handleVncClipboardPasteShortcut } from "@/components/browserStreamClipboard";
+import {
+ handleVncClipboardPasteShortcut,
+ type HeldMetaSides,
+} from "@/components/browserStreamClipboard";
import "./browser-stream.css";
@@ -347,6 +350,10 @@ function BrowserStream({
const rfbRef = useRef<RFB | null>(null);
const onActivityRef = useRef(onActivity);
const userCanSendVncInputRef = useRef(false);
+ const heldMetaSidesRef = useRef<HeldMetaSides>({
+ left: false,
+ right: false,
+ });
const observerRef = useRef<MutationObserver | null>(null);
const messageReconnectAttemptsRef = useRef(0);
const messageReconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(
@@ -927,16 +934,63 @@ function BrowserStream({
}
const handleKeyDown = (event: KeyboardEvent) => {
+ // Track only Meta keydowns noVNC's canvas receives: restoring a side noVNC never tracked would strand the modifier remotely, since noVNC drops keyups for keys it never saw down.
+ if (event.key === "Meta" && event.target instanceof HTMLCanvasElement) {
+ if (event.code === "MetaLeft") {
+ heldMetaSidesRef.current = {
+ ...heldMetaSidesRef.current,
+ left: true,
+ };
+ } else if (event.code === "MetaRight") {
+ heldMetaSidesRef.current = {
+ ...heldMetaSidesRef.current,
+ right: true,
+ };
+ }
+ }
+
if (!userCanSendVncInputRef.current) {
return;
}
- void handleVncClipboardPasteShortcut(event, rfbRef.current);
+ void handleVncClipboardPasteShortcut(event, rfbRef.current, {
+ getHeldMetaSides: () => heldMetaSidesRef.current,
+ onPasteError: () => {
+ toast({
+ title: "Paste failed",
+ description:
+ "Skyvern couldn't read your clipboard. Allow clipboard access for this site and try again.",
+ variant: "destructive",
+ });
+ },
+ });
+ };
+
+ const handleKeyUp = (event: KeyboardEvent) => {
+ if (event.key === "Meta" && event.code === "MetaLeft") {
+ heldMetaSidesRef.current = {
+ ...heldMetaSidesRef.current,
+ left: false,
+ };
+ } else if (event.key === "Meta" && event.code === "MetaRight") {
+ heldMetaSidesRef.current = {
+ ...heldMetaSidesRef.current,
+ right: false,
+ };
+ }
+ };
+
+ const handleBlur = () => {
+ heldMetaSidesRef.current = { left: false, right: false };
};
canvasContainer.addEventListener("keydown", handleKeyDown, true);
+ window.addEventListener("keyup", handleKeyUp, true);
+ window.addEventListener("blur", handleBlur);
return () => {
canvasContainer.removeEventListener("keydown", handleKeyDown, true);
+ window.removeEventListener("keyup", handleKeyUp, true);
+ window.removeEventListener("blur", handleBlur);
};
}, [canvasContainer]);
diff --git a/skyvern-frontend/src/components/browserStreamClipboard.test.ts b/skyvern-frontend/src/components/browserStreamClipboard.test.ts
index 17b4b7c02..b5d139a5b 100644
--- a/skyvern-frontend/src/components/browserStreamClipboard.test.ts
+++ b/skyvern-frontend/src/components/browserStreamClipboard.test.ts
@@ -62,40 +62,191 @@ describe("browserStreamClipboard", () => {
);
});
- it("syncs local clipboard text to VNC before sending paste", async () => {
- const event = pasteEvent();
+ it("releases and restores tracked left Cmd around remote Ctrl+V", async () => {
+ const event = pasteEvent({ ctrlKey: false, metaKey: true });
const rfb = rfbMock();
+ const getHeldMetaSides = vi.fn(() => ({ left: true, right: false }));
- await handleVncClipboardPasteShortcut(
- event,
- rfb,
- async () => "https://example.test",
- 0,
- );
+ await handleVncClipboardPasteShortcut(event, rfb, {
+ getHeldMetaSides,
+ readClipboardText: async () => "https://example.test",
+ syncDelayMs: 0,
+ });
expect(event.preventDefault).toHaveBeenCalledOnce();
expect(event.stopPropagation).toHaveBeenCalledOnce();
expect(event.stopImmediatePropagation).toHaveBeenCalledOnce();
expect(rfb.clipboardPasteFrom).toHaveBeenCalledWith("https://example.test");
+ expect(getHeldMetaSides).toHaveBeenCalledTimes(2);
+ expect(rfb.sendKey).toHaveBeenCalledTimes(6);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(1, 0xffe9, "MetaLeft", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(2, 0xffe3, "ControlLeft", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(3, 0x0076, "KeyV", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(4, 0x0076, "KeyV", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(
+ 5,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(6, 0xffe9, "MetaLeft", true);
+ expect(rfb.clipboardPasteFrom.mock.invocationCallOrder[0]).toBeLessThan(
+ rfb.sendKey.mock.invocationCallOrder[0]!,
+ );
+ });
+
+ it("releases and restores tracked right Cmd around remote Ctrl+V", async () => {
+ const event = pasteEvent({ ctrlKey: false, metaKey: true });
+ const rfb = rfbMock();
+ const getHeldMetaSides = vi.fn(() => ({ left: false, right: true }));
+
+ await handleVncClipboardPasteShortcut(event, rfb, {
+ getHeldMetaSides,
+ readClipboardText: async () => "https://example.test",
+ syncDelayMs: 0,
+ });
+
+ expect(getHeldMetaSides).toHaveBeenCalledTimes(2);
+ expect(rfb.sendKey).toHaveBeenCalledTimes(6);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(1, 0xffeb, "MetaRight", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(2, 0xffe3, "ControlLeft", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(3, 0x0076, "KeyV", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(4, 0x0076, "KeyV", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(
+ 5,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(6, 0xffeb, "MetaRight", true);
+ });
+
+ it("does not restore Cmd when it is released during clipboard sync", async () => {
+ const event = pasteEvent({ ctrlKey: false, metaKey: true });
+ const rfb = rfbMock();
+ const getHeldMetaSides = vi.fn(() => ({ left: false, right: false }));
+
+ await handleVncClipboardPasteShortcut(event, rfb, {
+ getHeldMetaSides,
+ readClipboardText: async () => "https://example.test",
+ syncDelayMs: 0,
+ });
+
+ expect(getHeldMetaSides).toHaveBeenCalledOnce();
+ expect(rfb.sendKey).toHaveBeenCalledTimes(8);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(1, 0xffe9, "AltLeft", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(2, 0xffea, "AltRight", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(3, 0xffeb, "MetaLeft", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(4, 0xffec, "MetaRight", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(5, 0xffe3, "ControlLeft", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(6, 0x0076, "KeyV", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(7, 0x0076, "KeyV", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(
+ 8,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ });
+
+ it("uses the freshly held Cmd side after a side swap during clipboard sync", async () => {
+ const event = pasteEvent({ ctrlKey: false, metaKey: true });
+ const rfb = rfbMock();
+ const getHeldMetaSides = vi.fn(() => ({ left: false, right: true }));
+
+ await handleVncClipboardPasteShortcut(event, rfb, {
+ getHeldMetaSides,
+ readClipboardText: async () => "https://example.test",
+ syncDelayMs: 0,
+ });
+
+ expect(getHeldMetaSides).toHaveBeenCalledTimes(2);
+ expect(rfb.sendKey).toHaveBeenCalledTimes(6);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(1, 0xffeb, "MetaRight", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(2, 0xffe3, "ControlLeft", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(3, 0x0076, "KeyV", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(4, 0x0076, "KeyV", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(
+ 5,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(6, 0xffeb, "MetaRight", true);
+ });
+
+ it("falls back to blanket Cmd release without restoring untracked sides", async () => {
+ const event = pasteEvent({ ctrlKey: false, metaKey: true });
+ const rfb = rfbMock();
+
+ await handleVncClipboardPasteShortcut(event, rfb, {
+ readClipboardText: async () => "https://example.test",
+ syncDelayMs: 0,
+ });
+
+ expect(rfb.sendKey).toHaveBeenCalledTimes(8);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(1, 0xffe9, "AltLeft", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(2, 0xffea, "AltRight", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(3, 0xffeb, "MetaLeft", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(4, 0xffec, "MetaRight", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(5, 0xffe3, "ControlLeft", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(6, 0x0076, "KeyV", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(7, 0x0076, "KeyV", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(
+ 8,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ });
+
+ it("preserves the remote Ctrl+V sequence for Ctrl-only paste", async () => {
+ const event = pasteEvent();
+ const rfb = rfbMock();
+ const getHeldMetaSides = vi.fn(() => ({ left: true, right: false }));
+
+ await handleVncClipboardPasteShortcut(event, rfb, {
+ getHeldMetaSides,
+ readClipboardText: async () => "https://example.test",
+ syncDelayMs: 0,
+ });
+
+ expect(getHeldMetaSides).not.toHaveBeenCalled();
expect(rfb.sendKey).toHaveBeenCalledTimes(4);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(1, 0xffe3, "ControlLeft", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(2, 0x0076, "KeyV", true);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(3, 0x0076, "KeyV", false);
+ expect(rfb.sendKey).toHaveBeenNthCalledWith(
+ 4,
+ 0xffe3,
+ "ControlLeft",
+ false,
+ );
+ expect(rfb.sendKey).not.toHaveBeenCalledWith(0xffe9, "AltLeft", false);
+ expect(rfb.sendKey).not.toHaveBeenCalledWith(0xffea, "AltRight", false);
+ expect(rfb.sendKey).not.toHaveBeenCalledWith(0xffeb, "MetaLeft", false);
+ expect(rfb.sendKey).not.toHaveBeenCalledWith(0xffec, "MetaRight", false);
});
it("does not send stale VNC clipboard contents when browser clipboard read fails", async () => {
const event = pasteEvent();
const rfb = rfbMock();
+ const error = new Error("denied");
+ const onPasteError = vi.fn();
await expect(
- handleVncClipboardPasteShortcut(
- event,
- rfb,
- async () => {
- throw new Error("denied");
+ handleVncClipboardPasteShortcut(event, rfb, {
+ onPasteError,
+ readClipboardText: async () => {
+ throw error;
},
- 0,
- ),
+ syncDelayMs: 0,
+ }),
).resolves.toBe(true);
expect(event.preventDefault).toHaveBeenCalledOnce();
+ expect(onPasteError).toHaveBeenCalledWith(error);
+ expect(onPasteError).toHaveBeenCalledTimes(1);
expect(rfb.clipboardPasteFrom).not.toHaveBeenCalled();
expect(rfb.sendKey).not.toHaveBeenCalled();
});
@@ -105,7 +256,9 @@ describe("browserStreamClipboard", () => {
const rfb = rfbMock();
await expect(
- handleVncClipboardPasteShortcut(event, rfb, async () => "ignored"),
+ handleVncClipboardPasteShortcut(event, rfb, {
+ readClipboardText: async () => "ignored",
+ }),
).resolves.toBe(false);
expect(event.preventDefault).not.toHaveBeenCalled();
diff --git a/skyvern-frontend/src/components/browserStreamClipboard.ts b/skyvern-frontend/src/components/browserStreamClipboard.ts
index 4c77479ed..24a395337 100644
--- a/skyvern-frontend/src/components/browserStreamClipboard.ts
+++ b/skyvern-frontend/src/components/browserStreamClipboard.ts
@@ -3,6 +3,8 @@ export interface VncClipboardRfb {
sendKey(keysym: number, code: string, down?: boolean): void;
}
+export type HeldMetaSides = { left: boolean; right: boolean };
+
export type PasteShortcutEvent = Pick<
KeyboardEvent,
| "altKey"
@@ -17,6 +19,15 @@ export type PasteShortcutEvent = Pick<
const VNC_CONTROL_LEFT_KEYSYM = 0xffe3;
const VNC_V_KEYSYM = 0x0076;
+// noVNC maps physical macOS left Cmd to Alt_L and right Cmd to Super_L on this path.
+const VNC_CMD_LEFT_RELEASE_KEYSYM = 0xffe9;
+const VNC_CMD_RIGHT_RELEASE_KEYSYM = 0xffeb;
+const VNC_BLANKET_META_RELEASES: Array<{ keysym: number; code: string }> = [
+ { keysym: 0xffe9, code: "AltLeft" },
+ { keysym: 0xffea, code: "AltRight" },
+ { keysym: 0xffeb, code: "MetaLeft" },
+ { keysym: 0xffec, code: "MetaRight" },
+];
const DEFAULT_VNC_CLIPBOARD_SYNC_DELAY_MS = 50;
function sleep(ms: number) {
@@ -33,7 +44,15 @@ function isClipboardPasteShortcut(event: PasteShortcutEvent) {
);
}
-function sendVncPasteShortcut(rfb: VncClipboardRfb) {
+function sendVncPasteShortcut(
+ rfb: VncClipboardRfb,
+ releaseMetaModifiers = false,
+) {
+ if (releaseMetaModifiers) {
+ for (const { keysym, code } of VNC_BLANKET_META_RELEASES) {
+ rfb.sendKey(keysym, code, false);
+ }
+ }
rfb.sendKey(VNC_CONTROL_LEFT_KEYSYM, "ControlLeft", true);
rfb.sendKey(VNC_V_KEYSYM, "KeyV", true);
rfb.sendKey(VNC_V_KEYSYM, "KeyV", false);
@@ -43,13 +62,24 @@ function sendVncPasteShortcut(rfb: VncClipboardRfb) {
async function handleVncClipboardPasteShortcut(
event: PasteShortcutEvent,
rfb: VncClipboardRfb | null,
- readClipboardText = () => navigator.clipboard.readText(),
- syncDelayMs = DEFAULT_VNC_CLIPBOARD_SYNC_DELAY_MS,
+ options?: {
+ readClipboardText?: () => Promise<string>;
+ syncDelayMs?: number;
+ onPasteError?: (err: unknown) => void;
+ getHeldMetaSides?: () => HeldMetaSides;
+ },
) {
if (!rfb || !isClipboardPasteShortcut(event)) {
return false;
}
+ const {
+ readClipboardText = () => navigator.clipboard.readText(),
+ syncDelayMs = DEFAULT_VNC_CLIPBOARD_SYNC_DELAY_MS,
+ onPasteError,
+ getHeldMetaSides,
+ } = options ?? {};
+
event.preventDefault();
event.stopPropagation();
event.stopImmediatePropagation();
@@ -62,10 +92,37 @@ async function handleVncClipboardPasteShortcut(
}
} catch (err) {
console.error("Failed to sync clipboard contents to VNC:", err);
+ onPasteError?.(err);
return true;
}
+ if (!event.metaKey) {
+ sendVncPasteShortcut(rfb);
+ return true;
+ }
+
+ const sides = getHeldMetaSides?.();
+ if (!sides?.left && !sides?.right) {
+ sendVncPasteShortcut(rfb, true);
+ return true;
+ }
+
+ if (sides.left) {
+ rfb.sendKey(VNC_CMD_LEFT_RELEASE_KEYSYM, "MetaLeft", false);
+ }
+ if (sides.right) {
+ rfb.sendKey(VNC_CMD_RIGHT_RELEASE_KEYSYM, "MetaRight", false);
+ }
+
sendVncPasteShortcut(rfb);
+
+ const currentMetaSides = getHeldMetaSides?.();
+ if (currentMetaSides?.left) {
+ rfb.sendKey(VNC_CMD_LEFT_RELEASE_KEYSYM, "MetaLeft", true);
+ }
+ if (currentMetaSides?.right) {
+ rfb.sendKey(VNC_CMD_RIGHT_RELEASE_KEYSYM, "MetaRight", true);
+ }
return true;
}
diff --git a/skyvern/cli/mcp_tools/README.md b/skyvern/cli/mcp_tools/README.md
index bc3a37e60..ee94f6e1b 100644
--- a/skyvern/cli/mcp_tools/README.md
+++ b/skyvern/cli/mcp_tools/README.md
@@ -87,7 +87,7 @@ Manual config for any MCP client:
`skyvern_extract` (structured JSON output), `skyvern_screenshot`, `skyvern_find`, `skyvern_validate`, `skyvern_evaluate` (run JavaScript), `skyvern_get_html`, `skyvern_get_value`, `skyvern_get_styles`
### Authentication & Credentials
-`skyvern_login`, `skyvern_credential_list`, `skyvern_credential_get`, `skyvern_credential_delete`
+`skyvern_login`, `skyvern_credential_list`, `skyvern_credential_get`, `skyvern_credential_delete`, `skyvern_onepassword_items`, `skyvern_onepassword_config_get`, `skyvern_onepassword_config_set`, `skyvern_onepassword_config_clear`, `skyvern_bitwarden_items`, `skyvern_bitwarden_config_get`, `skyvern_bitwarden_config_set`, `skyvern_bitwarden_config_clear`
Supports Skyvern vault, Bitwarden, 1Password, and Azure Key Vault with automatic 2FA/TOTP.
diff --git a/skyvern/cli/mcp_tools/__init__.py b/skyvern/cli/mcp_tools/__init__.py
index c12a6d6f7..66585c3ae 100644
--- a/skyvern/cli/mcp_tools/__init__.py
+++ b/skyvern/cli/mcp_tools/__init__.py
@@ -92,9 +92,17 @@ from .browser_profiles import (
from .cdp_input import skyvern_write_grid
from .code_block import skyvern_code_block_lint, skyvern_code_block_synthesize
from .credential import (
+ skyvern_bitwarden_config_clear,
+ skyvern_bitwarden_config_get,
+ skyvern_bitwarden_config_set,
+ skyvern_bitwarden_items,
skyvern_credential_delete,
skyvern_credential_get,
skyvern_credential_list,
+ skyvern_onepassword_config_clear,
+ skyvern_onepassword_config_get,
+ skyvern_onepassword_config_set,
+ skyvern_onepassword_items,
)
from .folder import (
skyvern_folder_create,
@@ -305,14 +313,20 @@ file_upload, find, navigate, screenshot, evaluate
- **Workflows:** workflow_create/run/status/get/list/update/delete/cancel/update_folder
- **Schedules:** schedule_list/list_for_workflow/get/create/update/enable/disable/delete
- **Scripts:** script_list_for_workflow, script_get_code, script_versions, script_fallback_episodes, script_deploy
-- **Credentials:** credential_list/get/delete
+- **Credentials:** credential_list/get/delete, onepassword_items/config_get/config_set/config_clear, \
+bitwarden_items/config_get/config_set/config_clear
- **Folders/Blocks:** folder_list/get/create/update/delete, block_schema, block_validate
+Provider config_set tools never accept secrets as arguments. Set OP_SERVICE_ACCOUNT_TOKEN or \
+BITWARDEN_MASTER_PASSWORD in the MCP server environment before starting it, then call the matching tool. \
+Never include provider secrets in chat or tool arguments.
+
Precision tools support intent (AI), selector (deterministic), or hybrid (both) targeting.
### Dependencies
- extract/validate read the CURRENT page — navigate first.
-- login requires a session AND a credential_id from credential_list.
+- login requires a session AND either a credential_id from credential_list or provider IDs from \
+onepassword_items/bitwarden_items.
- file_upload requires a navigated page with an upload element.
- console_messages and network_requests capture events from session start — call anytime.
- Workflow, schedule, credential, script, folder, and block tools do NOT need a browser session.
@@ -515,6 +529,24 @@ mcp.tool(tags={"settings"}, annotations=_mut("Update Organization Settings"))(sk
mcp.tool(tags={"credential"}, annotations=_ro("List Credentials"))(skyvern_credential_list)
mcp.tool(tags={"credential"}, annotations=_ro("Get Credential"))(skyvern_credential_get)
mcp.tool(tags={"credential"}, annotations=_dest("Delete Credential"))(skyvern_credential_delete)
+mcp.tool(tags={"credential", "onepassword"}, annotations=_ro("List 1Password Items"))(skyvern_onepassword_items)
+mcp.tool(tags={"credential", "onepassword"}, annotations=_ro("Get 1Password Configuration"))(
+ skyvern_onepassword_config_get
+)
+mcp.tool(tags={"credential", "onepassword"}, annotations=_mut("Set 1Password Configuration"))(
+ skyvern_onepassword_config_set
+)
+mcp.tool(tags={"credential", "onepassword"}, annotations=_dest("Clear 1Password Configuration"))(
+ skyvern_onepassword_config_clear
+)
+mcp.tool(tags={"credential", "bitwarden"}, annotations=_ro("List Bitwarden Items"))(skyvern_bitwarden_items)
+mcp.tool(tags={"credential", "bitwarden"}, annotations=_ro("Get Bitwarden Configuration"))(skyvern_bitwarden_config_get)
+mcp.tool(tags={"credential", "bitwarden"}, annotations=_mut("Set Bitwarden Configuration"))(
+ skyvern_bitwarden_config_set
+)
+mcp.tool(tags={"credential", "bitwarden"}, annotations=_dest("Clear Bitwarden Configuration"))(
+ skyvern_bitwarden_config_clear
+)
# -- Folder management (no browser needed) --
mcp.tool(tags={"folder"}, annotations=_ro("List Folders"))(skyvern_folder_list)
@@ -645,6 +677,14 @@ __all__ = [
"skyvern_credential_list",
"skyvern_credential_get",
"skyvern_credential_delete",
+ "skyvern_onepassword_items",
+ "skyvern_onepassword_config_get",
+ "skyvern_onepassword_config_set",
+ "skyvern_onepassword_config_clear",
+ "skyvern_bitwarden_items",
+ "skyvern_bitwarden_config_get",
+ "skyvern_bitwarden_config_set",
+ "skyvern_bitwarden_config_clear",
# Folder management
"skyvern_folder_list",
"skyvern_folder_create",
diff --git a/skyvern/cli/mcp_tools/_common.py b/skyvern/cli/mcp_tools/_common.py
index aaf800fd4..28368af3c 100644
--- a/skyvern/cli/mcp_tools/_common.py
+++ b/skyvern/cli/mcp_tools/_common.py
@@ -42,6 +42,22 @@ async def raw_http_put(path: str, json_body: dict[str, Any] | None = None) -> An
return await _raw_http_request("PUT", path, json_body=json_body)
+async def raw_http_post(path: str, json_body: dict[str, Any] | None = None) -> Any:
+ """POST request to Skyvern API for endpoints without SDK methods.
+
+ Raises NotFoundError on 404, RuntimeError on other HTTP errors.
+ """
+ return await _raw_http_request("POST", path, json_body=json_body)
+
+
+async def raw_http_delete(path: str) -> Any:
+ """DELETE request to Skyvern API for endpoints without SDK methods.
+
+ Raises NotFoundError on 404, RuntimeError on other HTTP errors.
+ """
+ return await _raw_http_request("DELETE", path)
+
+
async def _raw_http_request(
method: str,
path: str,
@@ -86,7 +102,9 @@ __all__ = [
"get_artifact_dir",
"make_error",
"make_result",
+ "raw_http_delete",
"raw_http_get",
+ "raw_http_post",
"raw_http_put",
"save_artifact",
]
diff --git a/skyvern/cli/mcp_tools/credential.py b/skyvern/cli/mcp_tools/credential.py
index 605f7d556..edeacce23 100644
--- a/skyvern/cli/mcp_tools/credential.py
+++ b/skyvern/cli/mcp_tools/credential.py
@@ -11,11 +11,40 @@ from typing import Annotated, Any
from pydantic import Field
+from skyvern.cli.core.client import has_api_key_override
from skyvern.client.core.api_error import ApiError
+from skyvern.client.errors import NotFoundError
+from skyvern.config import settings
-from ._common import ErrorCode, Timer, make_error, make_result
+from ._common import ErrorCode, Timer, make_error, make_result, raw_http_delete, raw_http_get, raw_http_post
from ._session import get_skyvern
+_ONEPASSWORD_GET_PATH = "v1/credentials/onepassword/get"
+_ONEPASSWORD_ITEMS_PATH = "v1/credentials/onepassword/items"
+_ONEPASSWORD_CREATE_PATH = "v1/credentials/onepassword/create"
+_ONEPASSWORD_CLEAR_PATH = "v1/credentials/onepassword"
+_BITWARDEN_GET_PATH = "v1/credentials/bitwarden/get"
+_BITWARDEN_ITEMS_PATH = "v1/credentials/bitwarden/items"
+_BITWARDEN_CREATE_PATH = "v1/credentials/bitwarden/create"
+_BITWARDEN_CLEAR_PATH = "v1/credentials/bitwarden"
+_ONEPASSWORD_TOKEN_ENV = "OP_SERVICE_ACCOUNT_TOKEN"
+_BITWARDEN_MASTER_PASSWORD_ENV = "BITWARDEN_MASTER_PASSWORD"
+_REDACTED = "***redacted***"
+_PROVIDER_CONFIG_SET_SINGLE_TENANT_ERROR = (
+ "Provider configuration setters are only available in single-tenant (stdio/local) mode."
+)
+_SECRET_FIELD_NAMES = frozenset(
+ {
+ "api_key",
+ "client_secret",
+ "master_password",
+ "password",
+ "secret",
+ "token",
+ }
+)
+_BITWARDEN_CREDENTIAL_TYPES = frozenset({"password", "credit_card", "secret"})
+
def _not_found_error(tool: str, credential_id: str, timer: Timer) -> dict[str, Any]:
return make_result(
@@ -80,6 +109,160 @@ def _serialize_credential(cred: Any) -> dict[str, Any]:
return data
+def _redact_secrets(value: Any) -> Any:
+ if isinstance(value, dict):
+ redacted: dict[str, Any] = {}
+ for key, nested_value in value.items():
+ if key in _SECRET_FIELD_NAMES and not isinstance(nested_value, (dict, list)):
+ redacted[key] = None if nested_value is None else _REDACTED
+ else:
+ redacted[key] = _redact_secrets(nested_value)
+ return redacted
+ if isinstance(value, list):
+ return [_redact_secrets(item) for item in value]
+ return value
+
+
+def _safe_config_payload(data: Any) -> dict[str, Any]:
+ """Return provider config metadata while stripping secret material."""
+ if not isinstance(data, dict):
+ return {"configured": True, "response": _redact_secrets(data)}
+
+ token = data.get("token")
+ if isinstance(token, dict):
+ safe_token = {key: _redact_secrets(value) for key, value in token.items() if key != "token"}
+ return {"configured": True, "token": safe_token}
+
+ return {"configured": True, "response": _redact_secrets(data)}
+
+
+def _configured_false(provider: str) -> dict[str, Any]:
+ return {"configured": False, "provider": provider}
+
+
+def _missing_provider_secret(tool: str, provider: str, env_var: str) -> dict[str, Any]:
+ return make_result(
+ tool,
+ ok=False,
+ error=make_error(
+ ErrorCode.INVALID_INPUT,
+ f"{provider} secret is not configured in the MCP server environment",
+ f"Set {env_var} before starting the MCP server, then call this tool again",
+ ),
+ )
+
+
+def _request_scoped_provider_config_error(tool: str) -> dict[str, Any]:
+ return make_result(
+ tool,
+ ok=False,
+ error=make_error(
+ ErrorCode.INVALID_INPUT,
+ _PROVIDER_CONFIG_SET_SINGLE_TENANT_ERROR,
+ "Use stdio/local MCP transport to configure provider credentials.",
+ ),
+ )
+
+
+def _matches_search(item: dict[str, Any], search: str | None) -> bool:
+ if not search:
+ return True
+ needle = search.casefold()
+ searchable_fields = ("title", "url", "item_id", "vault_id", "vault_name", "collection_id", "credential_type")
+ return any(needle in str(item.get(field, "")).casefold() for field in searchable_fields)
+
+
+def _filter_provider_items(
+ data: Any,
+ *,
+ tool: str,
+ search: str | None,
+ limit: int,
+ exact_matches: dict[str, str | None],
+) -> dict[str, Any]:
+ if not isinstance(data, dict) or "configured" not in data or "items" not in data:
+ return make_result(
+ tool,
+ ok=False,
+ error=make_error(
+ ErrorCode.API_ERROR,
+ "Unexpected provider items response",
+ "Check your Skyvern API version and connection",
+ ),
+ )
+
+ items = data.get("items")
+ if not isinstance(items, list):
+ return make_result(
+ tool,
+ ok=False,
+ error=make_error(
+ ErrorCode.API_ERROR,
+ "Provider items response did not include an items list",
+ "Check your Skyvern API version and connection",
+ ),
+ )
+
+ filtered_items: list[dict[str, Any]] = []
+ for item in items:
+ if not isinstance(item, dict):
+ continue
+ if not _matches_search(item, search):
+ continue
+ if any(expected is not None and str(item.get(field)) != expected for field, expected in exact_matches.items()):
+ continue
+ filtered_items.append(item)
+
+ limited_items = filtered_items[:limit]
+ return {
+ "configured": bool(data["configured"]),
+ "items": limited_items,
+ "count": len(limited_items),
+ "matched_count": len(filtered_items),
+ "total_count": len(items),
+ "has_more": len(filtered_items) > len(limited_items),
+ }
+
+
+async def _get_provider_config(tool: str, provider: str, path: str) -> dict[str, Any]:
+ with Timer() as timer:
+ try:
+ data = await raw_http_get(path)
+ timer.mark("http")
+ except NotFoundError:
+ return make_result(tool, data=_configured_false(provider), timing_ms=timer.timing_ms)
+ except Exception as e:
+ return make_result(
+ tool,
+ ok=False,
+ timing_ms=timer.timing_ms,
+ error=make_error(ErrorCode.API_ERROR, str(e), "Check your API key and Skyvern connection"),
+ )
+
+ return make_result(tool, data=_safe_config_payload(data), timing_ms=timer.timing_ms)
+
+
+async def _clear_provider_config(tool: str, provider: str, path: str) -> dict[str, Any]:
+ with Timer() as timer:
+ try:
+ data = await raw_http_delete(path)
+ timer.mark("http")
+ except Exception as e:
+ return make_result(
+ tool,
+ ok=False,
+ timing_ms=timer.timing_ms,
+ error=make_error(ErrorCode.API_ERROR, str(e), "Check your API key and Skyvern connection"),
+ )
+
+ success = data.get("success", True) if isinstance(data, dict) else True
+ return make_result(
+ tool,
+ data={"provider": provider, "cleared": bool(success)},
+ timing_ms=timer.timing_ms,
+ )
+
+
async def skyvern_credential_list(
page: Annotated[int, Field(description="Page number (1-based)", ge=1)] = 1,
page_size: Annotated[int, Field(description="Results per page", ge=1, le=100)] = 10,
@@ -301,3 +484,173 @@ async def skyvern_credential_delete(
data={"credential_id": credential_id, "deleted": True},
timing_ms=timer.timing_ms,
)
+
+
+async def skyvern_onepassword_items(
+ search: Annotated[
+ str | None,
+ Field(description="Optional case-insensitive filter across title, URL, vault name, vault ID, and item ID"),
+ ] = None,
+ vault_id: Annotated[str | None, Field(description="Optional exact 1Password vault ID filter")] = None,
+ limit: Annotated[int, Field(description="Maximum number of item metadata rows to return", ge=1, le=500)] = 100,
+) -> dict[str, Any]:
+ """List 1Password item metadata for this organization. Returns vault/item IDs, never item field values."""
+ with Timer() as timer:
+ try:
+ data = await raw_http_get(_ONEPASSWORD_ITEMS_PATH)
+ timer.mark("http")
+ except Exception as e:
+ return make_result(
+ "skyvern_onepassword_items",
+ ok=False,
+ timing_ms=timer.timing_ms,
+ error=make_error(ErrorCode.API_ERROR, str(e), "Check your 1Password configuration"),
+ )
+
+ items_data = _filter_provider_items(
+ data,
+ tool="skyvern_onepassword_items",
+ search=search,
+ limit=limit,
+ exact_matches={"vault_id": vault_id},
+ )
+ if items_data.get("ok") is False:
+ return items_data
+ return make_result("skyvern_onepassword_items", data=items_data, timing_ms=timer.timing_ms)
+
+
+async def skyvern_bitwarden_items(
+ search: Annotated[
+ str | None,
+ Field(description="Optional case-insensitive filter across title, URL, collection ID, item ID, and type"),
+ ] = None,
+ collection_id: Annotated[str | None, Field(description="Optional exact Bitwarden collection ID filter")] = None,
+ credential_type: Annotated[
+ str | None,
+ Field(description="Optional exact credential type filter: 'password', 'credit_card', or 'secret'"),
+ ] = None,
+ limit: Annotated[int, Field(description="Maximum number of item metadata rows to return", ge=1, le=500)] = 100,
+) -> dict[str, Any]:
+ """List Bitwarden item metadata for this organization. Returns collection/item IDs, never secret values."""
+ if credential_type is not None and credential_type not in _BITWARDEN_CREDENTIAL_TYPES:
+ return make_result(
+ "skyvern_bitwarden_items",
+ ok=False,
+ error=make_error(
+ ErrorCode.INVALID_INPUT,
+ f"Invalid credential_type: {credential_type!r}",
+ f"Use one of: {', '.join(sorted(_BITWARDEN_CREDENTIAL_TYPES))}",
+ ),
+ )
+
+ with Timer() as timer:
+ try:
+ data = await raw_http_get(_BITWARDEN_ITEMS_PATH)
+ timer.mark("http")
+ except Exception as e:
+ return make_result(
+ "skyvern_bitwarden_items",
+ ok=False,
+ timing_ms=timer.timing_ms,
+ error=make_error(ErrorCode.API_ERROR, str(e), "Check your Bitwarden configuration"),
+ )
+
+ items_data = _filter_provider_items(
+ data,
+ tool="skyvern_bitwarden_items",
+ search=search,
+ limit=limit,
+ exact_matches={"collection_id": collection_id, "credential_type": credential_type},
+ )
+ if items_data.get("ok") is False:
+ return items_data
+ return make_result("skyvern_bitwarden_items", data=items_data, timing_ms=timer.timing_ms)
+
+
+async def skyvern_onepassword_config_get() -> dict[str, Any]:
+ """Get 1Password configuration metadata for this organization. The service account token is never returned."""
+ return await _get_provider_config("skyvern_onepassword_config_get", "onepassword", _ONEPASSWORD_GET_PATH)
+
+
+async def skyvern_onepassword_config_set() -> dict[str, Any]:
+ """Store the 1Password token from OP_SERVICE_ACCOUNT_TOKEN. Set it before starting the MCP server."""
+ if has_api_key_override():
+ return _request_scoped_provider_config_error("skyvern_onepassword_config_set")
+
+ token = settings.OP_SERVICE_ACCOUNT_TOKEN
+ if not token:
+ return _missing_provider_secret(
+ "skyvern_onepassword_config_set",
+ "1Password",
+ _ONEPASSWORD_TOKEN_ENV,
+ )
+
+ with Timer() as timer:
+ try:
+ data = await raw_http_post(_ONEPASSWORD_CREATE_PATH, json_body={"token": token})
+ timer.mark("http")
+ except Exception:
+ return make_result(
+ "skyvern_onepassword_config_set",
+ ok=False,
+ timing_ms=timer.timing_ms,
+ error=make_error(
+ ErrorCode.API_ERROR,
+ "Failed to set 1Password configuration",
+ f"Check {_ONEPASSWORD_TOKEN_ENV} in the MCP server environment and the Skyvern connection",
+ ),
+ )
+
+ return make_result("skyvern_onepassword_config_set", data=_safe_config_payload(data), timing_ms=timer.timing_ms)
+
+
+async def skyvern_onepassword_config_clear() -> dict[str, Any]:
+ """Clear the 1Password service account token for this organization."""
+ return await _clear_provider_config("skyvern_onepassword_config_clear", "onepassword", _ONEPASSWORD_CLEAR_PATH)
+
+
+async def skyvern_bitwarden_config_get() -> dict[str, Any]:
+ """Get Bitwarden configuration metadata for this organization. The master password is never returned."""
+ return await _get_provider_config("skyvern_bitwarden_config_get", "bitwarden", _BITWARDEN_GET_PATH)
+
+
+async def skyvern_bitwarden_config_set(
+ email: Annotated[str, Field(description="Bitwarden account email")],
+) -> dict[str, Any]:
+ """Store the Bitwarden credential using BITWARDEN_MASTER_PASSWORD from the MCP server environment."""
+ if has_api_key_override():
+ return _request_scoped_provider_config_error("skyvern_bitwarden_config_set")
+
+ master_password = settings.BITWARDEN_MASTER_PASSWORD
+ if not master_password:
+ return _missing_provider_secret(
+ "skyvern_bitwarden_config_set",
+ "Bitwarden",
+ _BITWARDEN_MASTER_PASSWORD_ENV,
+ )
+
+ with Timer() as timer:
+ try:
+ data = await raw_http_post(
+ _BITWARDEN_CREATE_PATH,
+ json_body={"credential": {"email": email, "master_password": master_password}},
+ )
+ timer.mark("http")
+ except Exception:
+ return make_result(
+ "skyvern_bitwarden_config_set",
+ ok=False,
+ timing_ms=timer.timing_ms,
+ error=make_error(
+ ErrorCode.API_ERROR,
+ "Failed to set Bitwarden configuration",
+ f"Check {_BITWARDEN_MASTER_PASSWORD_ENV} in the MCP server environment and the Skyvern connection",
+ ),
+ )
+
+ return make_result("skyvern_bitwarden_config_set", data=_safe_config_payload(data), timing_ms=timer.timing_ms)
+
+
+async def skyvern_bitwarden_config_clear() -> dict[str, Any]:
+ """Clear the Bitwarden credential for this organization."""
+ return await _clear_provider_config("skyvern_bitwarden_config_clear", "bitwarden", _BITWARDEN_CLEAR_PATH)
diff --git a/tests/unit/test_mcp_common.py b/tests/unit/test_mcp_common.py
index a70b2494c..fee8f30b8 100644
--- a/tests/unit/test_mcp_common.py
+++ b/tests/unit/test_mcp_common.py
@@ -40,3 +40,29 @@ async def test_raw_http_get_returns_raw_text_for_non_json_success(monkeypatch: p
result = await common_tools.raw_http_get("v1/test")
assert result == {"raw": "<html>ok</html>"}
+
+
+async def test_raw_http_post_passes_json_body(monkeypatch: pytest.MonkeyPatch) -> None:
+ response = SimpleNamespace(status_code=200, text="", json=Mock(return_value={"ok": True}))
+ request = AsyncMock(return_value=response)
+ fake_client = SimpleNamespace(_client_wrapper=SimpleNamespace(httpx_client=SimpleNamespace(request=request)))
+ monkeypatch.setattr("skyvern.cli.mcp_tools._session.get_skyvern", lambda: fake_client)
+
+ result = await common_tools.raw_http_post("v1/test", json_body={"x": 1})
+
+ assert result == {"ok": True}
+ request.assert_awaited_once_with("v1/test", method="POST", params={}, json={"x": 1})
+
+
+async def test_raw_http_delete_uses_delete_method(monkeypatch: pytest.MonkeyPatch) -> None:
+ response = SimpleNamespace(status_code=200, text="", json=Mock(return_value={"success": True}))
+ request = AsyncMock(return_value=response)
+ fake_client = SimpleNamespace(_client_wrapper=SimpleNamespace(httpx_client=SimpleNamespace(request=request)))
+ monkeypatch.setattr("skyvern.cli.mcp_tools._session.get_skyvern", lambda: fake_client)
+
+ result = await common_tools.raw_http_delete("v1/test")
+
+ assert result == {"success": True}
+ request.assert_awaited_once_with("v1/test", method="DELETE", params={})
diff --git a/tests/unit/test_mcp_credential_provider_tools.py b/tests/unit/test_mcp_credential_provider_tools.py
new file mode 100644
index 000000000..0072c1a8c
--- /dev/null
+++ b/tests/unit/test_mcp_credential_provider_tools.py
@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+import skyvern.cli.mcp_tools.credential as credential_tools
+from skyvern.cli.core.client import reset_api_key_override, set_api_key_override
+from skyvern.cli.mcp_tools import mcp
+from skyvern.client.errors import NotFoundError
+
+
+async def test_onepassword_items_lists_metadata_with_filters(monkeypatch: pytest.MonkeyPatch) -> None:
+ raw_http_get = AsyncMock(
+ return_value={
+ "configured": True,
+ "items": [
+ {
+ "item_id": "item_keep",
+ "title": "Production Login",
+ "vault_id": "vault_prod",
+ "vault_name": "Production",
+ "category": "LOGIN",
+ "url": "https://app.example.com",
+ },
+ {
+ "item_id": "item_skip",
+ "title": "Staging Login",
+ "vault_id": "vault_stage",
+ "vault_name": "Staging",
+ "category": "LOGIN",
+ "url": "https://staging.example.com",
+ },
+ ],
+ }
+ )
+ monkeypatch.setattr(credential_tools, "raw_http_get", raw_http_get)
+
+ result = await credential_tools.skyvern_onepassword_items(search="production", vault_id="vault_prod", limit=10)
+
+ assert result["ok"] is True
+ raw_http_get.assert_awaited_once_with("v1/credentials/onepassword/items")
+ assert result["data"]["configured"] is True
+ assert result["data"]["count"] == 1
+ assert result["data"]["matched_count"] == 1
+ assert result["data"]["items"][0]["item_id"] == "item_keep"
+
+
+async def test_bitwarden_items_lists_metadata_with_filters(monkeypatch: pytest.MonkeyPatch) -> None:
+ raw_http_get = AsyncMock(
+ return_value={
+ "configured": True,
+ "items": [
+ {
+ "item_id": "item_keep",
+ "title": "Production Login",
+ "collection_id": "collection_prod",
+ "credential_type": "password",
+ "url": "https://app.example.com",
+ },
+ {
+ "item_id": "item_skip",
+ "title": "Production Card",
+ "collection_id": "collection_prod",
+ "credential_type": "credit_card",
+ "url": "https://app.example.com",
+ },
+ ],
+ }
+ )
+ monkeypatch.setattr(credential_tools, "raw_http_get", raw_http_get)
+
+ result = await credential_tools.skyvern_bitwarden_items(
+ search="production",
+ collection_id="collection_prod",
+ credential_type="password",
+ limit=10,
+ )
+
+ assert result["ok"] is True
+ raw_http_get.assert_awaited_once_with("v1/credentials/bitwarden/items")
+ assert result["data"]["count"] == 1
+ assert result["data"]["items"][0]["item_id"] == "item_keep"
+
+
+async def test_bitwarden_items_rejects_unknown_credential_type() -> None:
+ result = await credential_tools.skyvern_bitwarden_items(credential_type="bank_account")
+
+ assert result["ok"] is False
+ assert result["error"]["code"] == "INVALID_INPUT"
+
+
+async def test_onepassword_config_get_returns_unconfigured_on_404(monkeypatch: pytest.MonkeyPatch) -> None:
+ raw_http_get = AsyncMock(side_effect=NotFoundError(body={"detail": "missing"}))
+ monkeypatch.setattr(credential_tools, "raw_http_get", raw_http_get)
+
+ result = await credential_tools.skyvern_onepassword_config_get()
+
+ assert result["ok"] is True
+ raw_http_get.assert_awaited_once_with("v1/credentials/onepassword/get")
+ assert result["data"] == {"configured": False, "provider": "onepassword"}
+
+
+async def test_onepassword_config_set_redacts_service_account_token(monkeypatch: pytest.MonkeyPatch) -> None:
+ raw_http_post = AsyncMock(
+ return_value={
+ "token": {
+ "id": "oat_123",
+ "organization_id": "org_123",
+ "token_type": "onepassword_service_account",
+ "token": "op_secret",
+ "valid": True,
+ }
+ }
+ )
+ monkeypatch.setattr(credential_tools, "raw_http_post", raw_http_post)
+ monkeypatch.setattr(credential_tools.settings, "OP_SERVICE_ACCOUNT_TOKEN", "op_secret")
+
+ result = await credential_tools.skyvern_onepassword_config_set()
+
+ assert result["ok"] is True
+ raw_http_post.assert_awaited_once_with("v1/credentials/onepassword/create", json_body={"token": "op_secret"})
+ assert result["data"]["configured"] is True
+ assert result["data"]["token"]["id"] == "oat_123"
+ assert "token" not in result["data"]["token"]
+
+
+async def test_bitwarden_config_set_uses_environment_secret_and_accepts_safe_response(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ raw_http_post = AsyncMock(
+ return_value={
+ "token": {
+ "id": "oat_123",
+ "organization_id": "org_123",
+ "token_type": "bitwarden_credential",
+ "valid": True,
+ "credential": {
+ "email": "[email protected]",
+ },
+ }
+ }
+ )
+ monkeypatch.setattr(credential_tools, "raw_http_post", raw_http_post)
+ monkeypatch.setattr(credential_tools.settings, "BITWARDEN_MASTER_PASSWORD", "master-secret")
+
+ result = await credential_tools.skyvern_bitwarden_config_set(email="[email protected]")
+
+ assert result["ok"] is True
+ raw_http_post.assert_awaited_once_with(
+ "v1/credentials/bitwarden/create",
+ json_body={"credential": {"email": "[email protected]", "master_password": "master-secret"}},
+ )
+ assert result["data"]["token"]["credential"]["email"] == "[email protected]"
+ assert "master_password" not in result["data"]["token"]["credential"]
+
+
+def test_provider_config_redaction_is_a_defense_in_depth_backstop() -> None:
+ response = {
+ "token": {
+ "credential": {
+ "email": "[email protected]",
+ "master_password": "master-secret",
+ }
+ }
+ }
+
+ assert credential_tools._safe_config_payload(response) == {
+ "configured": True,
+ "token": {
+ "credential": {
+ "email": "[email protected]",
+ "master_password": "***redacted***",
+ }
+ },
+ }
+
+
+async def test_provider_config_set_tool_schemas_do_not_accept_secrets() -> None:
+ tools = {tool.name: tool for tool in await mcp.list_tools()}
+ secret_fields = {"token", "master_password", "password", "secret"}
+
+ onepassword_properties = tools["skyvern_onepassword_config_set"].parameters.get("properties", {})
+ bitwarden_properties = tools["skyvern_bitwarden_config_set"].parameters.get("properties", {})
+
+ assert not secret_fields.intersection(onepassword_properties)
+ assert not secret_fields.intersection(bitwarden_properties)
+ assert not onepassword_properties
+ assert set(bitwarden_properties) == {"email"}
+
+
+ ("tool_name", "setting_name", "env_var", "kwargs"),
+ [
+ ("skyvern_onepassword_config_set", "OP_SERVICE_ACCOUNT_TOKEN", "OP_SERVICE_ACCOUNT_TOKEN", {}),
+ (
+ "skyvern_bitwarden_config_set",
+ "BITWARDEN_MASTER_PASSWORD",
+ "BITWARDEN_MASTER_PASSWORD",
+ {"email": "[email protected]"},
+ ),
+ ],
+)
+async def test_provider_config_set_requires_secret_in_server_environment(
+ monkeypatch: pytest.MonkeyPatch,
+ tool_name: str,
+ setting_name: str,
+ env_var: str,
+ kwargs: dict[str, str],
+) -> None:
+ raw_http_post = AsyncMock()
+ monkeypatch.setattr(credential_tools, "raw_http_post", raw_http_post)
+ monkeypatch.setattr(credential_tools.settings, setting_name, None)
+
+ result = await getattr(credential_tools, tool_name)(**kwargs)
+
+ assert result["ok"] is False
+ assert result["error"]["code"] == "INVALID_INPUT"
+ assert env_var in result["error"]["hint"]
+ raw_http_post.assert_not_awaited()
+
+
+ ("tool_name", "setting_name", "secret", "kwargs"),
+ [
+ ("skyvern_onepassword_config_set", "OP_SERVICE_ACCOUNT_TOKEN", "host-op-secret", {}),
+ (
+ "skyvern_bitwarden_config_set",
+ "BITWARDEN_MASTER_PASSWORD",
+ "host-bitwarden-secret",
+ {"email": "[email protected]"},
+ ),
+ ],
+)
+async def test_provider_config_set_refuses_request_scoped_api_key_override(
+ monkeypatch: pytest.MonkeyPatch,
+ tool_name: str,
+ setting_name: str,
+ secret: str,
+ kwargs: dict[str, str],
+) -> None:
+ raw_http_post = AsyncMock()
+ monkeypatch.setattr(credential_tools, "raw_http_post", raw_http_post)
+ monkeypatch.setattr(credential_tools.settings, setting_name, secret)
+ override = set_api_key_override("request-api-key")
+
+ try:
+ result = await getattr(credential_tools, tool_name)(**kwargs)
+ finally:
+ reset_api_key_override(override)
+
+ assert result["ok"] is False
+ assert result["error"]["code"] == "INVALID_INPUT"
+ assert result["error"]["message"] == (
+ "Provider configuration setters are only available in single-tenant (stdio/local) mode."
+ )
+ assert secret not in repr(result)
+ assert "request-api-key" not in repr(result)
+ assert "[email protected]" not in repr(result)
+ raw_http_post.assert_not_awaited()
+
+
+ ("tool_name", "setting_name", "secret", "kwargs"),
+ [
+ ("skyvern_onepassword_config_set", "OP_SERVICE_ACCOUNT_TOKEN", "op_secret", {}),
+ (
+ "skyvern_bitwarden_config_set",
+ "BITWARDEN_MASTER_PASSWORD",
+ "master-secret",
+ {"email": "[email protected]"},
+ ),
+ ],
+)
+async def test_provider_config_set_errors_do_not_echo_request_input(
+ monkeypatch: pytest.MonkeyPatch,
+ tool_name: str,
+ setting_name: str,
+ secret: str,
+ kwargs: dict[str, str],
+) -> None:
+ request_input = (
+ {"token": secret}
+ if setting_name == "OP_SERVICE_ACCOUNT_TOKEN"
+ else {"credential": {"email": "[email protected]", "master_password": secret}}
+ )
+ raw_http_post = AsyncMock(side_effect=RuntimeError(f"HTTP 422: {request_input!r}"))
+ monkeypatch.setattr(credential_tools, "raw_http_post", raw_http_post)
+ monkeypatch.setattr(credential_tools.settings, setting_name, secret)
+
+ result = await getattr(credential_tools, tool_name)(**kwargs)
+
+ assert result["ok"] is False
+ assert secret not in repr(result)
+ assert repr(request_input) not in repr(result)
+
+
+async def test_provider_config_clear_calls_provider_delete_endpoint(monkeypatch: pytest.MonkeyPatch) -> None:
+ raw_http_delete = AsyncMock(return_value={"success": True})
+ monkeypatch.setattr(credential_tools, "raw_http_delete", raw_http_delete)
+
+ result = await credential_tools.skyvern_bitwarden_config_clear()
+
+ assert result["ok"] is True
+ raw_http_delete.assert_awaited_once_with("v1/credentials/bitwarden")
+ assert result["data"] == {"provider": "bitwarden", "cleared": True}
diff --git a/tests/unit/test_mcp_tool_titles.py b/tests/unit/test_mcp_tool_titles.py
index b04793089..197d27053 100644
--- a/tests/unit/test_mcp_tool_titles.py
+++ b/tests/unit/test_mcp_tool_titles.py
@@ -53,6 +53,8 @@ async def test_destructive_tools_flagged() -> None:
"skyvern_clear_session_storage",
"skyvern_clear_local_storage",
"skyvern_credential_delete",
+ "skyvern_onepassword_config_clear",
+ "skyvern_bitwarden_config_clear",
"skyvern_folder_delete",
"skyvern_workflow_delete",
"skyvern_workflow_cancel",
@@ -84,6 +86,10 @@ async def test_read_only_sampling_marked_read_only() -> None:
"skyvern_get_html",
"skyvern_workflow_list",
"skyvern_workflow_get",
+ "skyvern_onepassword_items",
+ "skyvern_onepassword_config_get",
+ "skyvern_bitwarden_items",
+ "skyvern_bitwarden_config_get",
}
for name in expected_ro:
@@ -127,6 +133,8 @@ async def test_open_world_sampling_matches_policy() -> None:
"skyvern_workflow_list",
"skyvern_folder_create",
"skyvern_credential_list",
+ "skyvern_onepassword_items",
+ "skyvern_bitwarden_items",
"skyvern_script_get_code",
}