Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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.mdindex 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__.pyindex 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_gridfrom .code_block import skyvern_code_block_lint, skyvern_code_block_synthesizefrom .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"))(skmcp.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.pyindex 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) -> Anreturn 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.pyindex 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, Anyfrom pydantic import Field+from skyvern.cli.core.client import has_api_key_overridefrom 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_postfrom ._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.pyindex 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: presult = 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.pynew file mode 100644index 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.pyindex 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",}