Skip to content

Automate browser based workflows with AI

fix(workflow-editor): Record Browser button stays visible while session loads (SKY-9777) (#5969)

pedrohsdb005274de8e3b
diff --git a/skyvern-frontend/src/components/BrowserStream.tsx b/skyvern-frontend/src/components/BrowserStream.tsx
index 2518f213d..77f6d043c 100644
--- a/skyvern-frontend/src/components/BrowserStream.tsx
+++ b/skyvern-frontend/src/components/BrowserStream.tsx
@@ -271,7 +271,8 @@ function BrowserStream({
};
}, [onReadyChange]);
- // update global settings store about browser usage
+ // `isUsingABrowser` is tied to local `isReady`, so this component owns it.
+ // `isLoadingABrowser` is owned by the route instead (SKY-9777).
useEffect(() => {
settingsStore.setIsUsingABrowser(isReady);
settingsStore.setBrowserSessionId(
diff --git a/skyvern-frontend/src/routes/workflows/editor/WorkflowAddMenu.tsx b/skyvern-frontend/src/routes/workflows/editor/WorkflowAddMenu.tsx
index 9124cfeac..a4792cefa 100644
--- a/skyvern-frontend/src/routes/workflows/editor/WorkflowAddMenu.tsx
+++ b/skyvern-frontend/src/routes/workflows/editor/WorkflowAddMenu.tsx
@@ -49,12 +49,14 @@ function WorkflowAddMenu({
},
];
- // Only show Record Browser when browser is ON
- if (settingsStore.isUsingABrowser) {
+ // Show Record Browser whenever a browser session exists (ready or still
+ // connecting). Disable it until the browser is actually ready so users
+ // can see the action will be available without it popping in mid-load.
+ if (settingsStore.isUsingABrowser || settingsStore.isLoadingABrowser) {
menuItems.push({
id: "2",
icon: <SquareIcon className={buttonSize ? "h-3 w-3" : undefined} />,
- enabled: !recordingStore.isRecording,
+ enabled: settingsStore.isUsingABrowser && !recordingStore.isRecording,
text: "Record Browser",
onClick: () => {
onRecord();
@@ -81,6 +83,7 @@ function WorkflowAddMenu({
onUploadSOP,
recordingStore.isRecording,
settingsStore.isUsingABrowser,
+ settingsStore.isLoadingABrowser,
isUploadingSOP,
]);
diff --git a/skyvern-frontend/src/routes/workflows/editor/Workspace.tsx b/skyvern-frontend/src/routes/workflows/editor/Workspace.tsx
index 52c35cfd7..8c3def95c 100644
--- a/skyvern-frontend/src/routes/workflows/editor/Workspace.tsx
+++ b/skyvern-frontend/src/routes/workflows/editor/Workspace.tsx
@@ -46,6 +46,7 @@ import { useCacheKeyValuesQuery } from "../hooks/useCacheKeyValuesQuery";
import { useBlockScriptStore } from "@/store/BlockScriptStore";
import { useRecordingStore } from "@/store/useRecordingStore";
import { useSidebarStore } from "@/store/SidebarStore";
+import { useBrowserLoadingFlag } from "../hooks/useBrowserLoadingFlag";
import { AnimatedWave } from "@/components/AnimatedWave";
import { Button } from "@/components/ui/button";
@@ -589,6 +590,8 @@ function Workspace({
[],
);
+ useBrowserLoadingFlag(shouldFetchDebugSession, readyBrowserSessionId);
+
const hasLoopBlock = nodes.some((node) => node.type === "loop");
const hasHttpBlock = nodes.some((node) => node.type === "http_request");
const workflowWidth = hasHttpBlock
diff --git a/skyvern-frontend/src/routes/workflows/editor/__tests__/WorkflowAddMenu.test.tsx b/skyvern-frontend/src/routes/workflows/editor/__tests__/WorkflowAddMenu.test.tsx
new file mode 100644
index 000000000..9b8711979
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/editor/__tests__/WorkflowAddMenu.test.tsx
@@ -0,0 +1,111 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import {
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+ type Mock,
+} from "vitest";
+
+import type { RadialMenuItem } from "@/components/RadialMenu";
+import { DebugStoreContext } from "@/store/DebugStoreContext";
+import { useRecordingStore } from "@/store/useRecordingStore";
+import { useSettingsStore } from "@/store/SettingsStore";
+
+const radialMenuMock = vi.fn(({ children }: { children: React.ReactNode }) => (
+ <div data-testid="radial-menu">{children}</div>
+));
+
+vi.mock("@/components/RadialMenu", () => ({
+ RadialMenu: (props: { items: RadialMenuItem[]; children: React.ReactNode }) =>
+ radialMenuMock(props),
+}));
+
+import { WorkflowAddMenu } from "../WorkflowAddMenu";
+
+const initialSettings = useSettingsStore.getState();
+const initialRecording = useRecordingStore.getState();
+
+function renderInDebugMode() {
+ return render(
+ <DebugStoreContext.Provider value={{ isDebugMode: true }}>
+ <WorkflowAddMenu
+ onAdd={() => {}}
+ onRecord={() => {}}
+ onUploadSOP={() => {}}
+ >
+ <span>child</span>
+ </WorkflowAddMenu>
+ </DebugStoreContext.Provider>,
+ );
+}
+
+function lastItems(): RadialMenuItem[] {
+ const calls = (radialMenuMock as Mock).mock.calls;
+ const last = calls[calls.length - 1];
+ return (last?.[0]?.items as RadialMenuItem[]) ?? [];
+}
+
+function recordBrowserItem(items: RadialMenuItem[]) {
+ return items.find((i) => i.text === "Record Browser");
+}
+
+describe("WorkflowAddMenu — Record Browser item visibility/enabled state", () => {
+ beforeEach(() => {
+ radialMenuMock.mockClear();
+ });
+
+ afterEach(() => {
+ useSettingsStore.setState(initialSettings, true);
+ useRecordingStore.setState(initialRecording, true);
+ cleanup();
+ });
+
+ it("does NOT show the Record Browser item when no session is using or loading (CORR-1 regression guard)", () => {
+ useSettingsStore.getState().setIsUsingABrowser(false);
+ useSettingsStore.getState().setIsLoadingABrowser(false);
+
+ renderInDebugMode();
+
+ expect(recordBrowserItem(lastItems())).toBeUndefined();
+ });
+
+ it("shows the Record Browser item as DISABLED while a session is loading", () => {
+ useSettingsStore.getState().setIsUsingABrowser(false);
+ useSettingsStore.getState().setIsLoadingABrowser(true);
+
+ renderInDebugMode();
+
+ const item = recordBrowserItem(lastItems());
+ expect(item).toBeDefined();
+ expect(item?.enabled).toBe(false);
+ });
+
+ it("shows the Record Browser item as ENABLED once the browser is ready and not recording", () => {
+ useSettingsStore.getState().setIsUsingABrowser(true);
+ useSettingsStore.getState().setIsLoadingABrowser(false);
+ useRecordingStore.setState({ isRecording: false });
+
+ renderInDebugMode();
+
+ const item = recordBrowserItem(lastItems());
+ expect(item).toBeDefined();
+ expect(item?.enabled).toBe(true);
+ });
+
+ it("disables the Record Browser item while recording is in progress, even when isUsingABrowser is true", () => {
+ useSettingsStore.getState().setIsUsingABrowser(true);
+ useSettingsStore.getState().setIsLoadingABrowser(false);
+ useRecordingStore.setState({ isRecording: true });
+
+ renderInDebugMode();
+
+ const item = recordBrowserItem(lastItems());
+ expect(item).toBeDefined();
+ expect(item?.enabled).toBe(false);
+ });
+});
diff --git a/skyvern-frontend/src/routes/workflows/hooks/__tests__/useBrowserLoadingFlag.test.tsx b/skyvern-frontend/src/routes/workflows/hooks/__tests__/useBrowserLoadingFlag.test.tsx
new file mode 100644
index 000000000..2a13ae1e2
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/hooks/__tests__/useBrowserLoadingFlag.test.tsx
@@ -0,0 +1,92 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { useSettingsStore } from "@/store/SettingsStore";
+
+import { useBrowserLoadingFlag } from "../useBrowserLoadingFlag";
+
+const initialSettings = useSettingsStore.getState();
+
+function Harness({
+ shouldFetchDebugSession,
+ readyBrowserSessionId,
+}: {
+ shouldFetchDebugSession: boolean;
+ readyBrowserSessionId: string | null;
+}) {
+ useBrowserLoadingFlag(shouldFetchDebugSession, readyBrowserSessionId);
+ return null;
+}
+
+describe("useBrowserLoadingFlag — closes the pre-mount visibility gap (SKY-9777)", () => {
+ beforeEach(() => {
+ useSettingsStore.setState(initialSettings, true);
+ });
+
+ afterEach(() => {
+ cleanup();
+ useSettingsStore.setState(initialSettings, true);
+ });
+
+ it("flips isLoadingABrowser to true as soon as session fetch begins, BEFORE BrowserStream mounts (regression: this is the window Winton screenshotted on the original PR)", () => {
+ // Editor mounts → useMountEffect → setShouldFetchDebugSession(true).
+ // useDebugSessionQuery is now polling. activeDebugSession is still null
+ // and therefore BrowserStream is NOT YET MOUNTED with a session id.
+ render(
+ <Harness shouldFetchDebugSession={true} readyBrowserSessionId={null} />,
+ );
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(true);
+ expect(useSettingsStore.getState().isUsingABrowser).toBe(false);
+ });
+
+ it("stays true through the BrowserStream connect window (session id known, VNC not yet ready)", () => {
+ // useDebugSessionQuery returned. activeDebugSession now has a
+ // browser_session_id. BrowserStream is mounted but VNC handshake hasn't
+ // completed → readyBrowserSessionId is still null.
+ render(
+ <Harness shouldFetchDebugSession={true} readyBrowserSessionId={null} />,
+ );
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(true);
+ });
+
+ it("flips isLoadingABrowser back to false once the browser is ready", () => {
+ const { rerender } = render(
+ <Harness shouldFetchDebugSession={true} readyBrowserSessionId={null} />,
+ );
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(true);
+
+ rerender(
+ <Harness
+ shouldFetchDebugSession={true}
+ readyBrowserSessionId="bs_test_ready"
+ />,
+ );
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(false);
+ });
+
+ it("stays false when the editor is not fetching a session (e.g. browser panel never opened)", () => {
+ render(
+ <Harness shouldFetchDebugSession={false} readyBrowserSessionId={null} />,
+ );
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(false);
+ });
+
+ it("clears the flag on unmount so navigating away doesn't strand the menu in loading state", () => {
+ const { unmount } = render(
+ <Harness shouldFetchDebugSession={true} readyBrowserSessionId={null} />,
+ );
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(true);
+
+ unmount();
+
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(false);
+ });
+});
diff --git a/skyvern-frontend/src/routes/workflows/hooks/useBrowserLoadingFlag.ts b/skyvern-frontend/src/routes/workflows/hooks/useBrowserLoadingFlag.ts
new file mode 100644
index 000000000..3ea92288d
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/hooks/useBrowserLoadingFlag.ts
@@ -0,0 +1,28 @@
+import { useEffect } from "react";
+
+import { useSettingsStore } from "@/store/SettingsStore";
+
+/**
+ * Drives `settingsStore.isLoadingABrowser` from the route level so the flag
+ * covers the API-fetch window before BrowserStream mounts (SKY-9777).
+ */
+function useBrowserLoadingFlag(
+ shouldFetchDebugSession: boolean,
+ readyBrowserSessionId: string | null,
+): void {
+ const setIsLoadingABrowser = useSettingsStore(
+ (state) => state.setIsLoadingABrowser,
+ );
+
+ useEffect(() => {
+ setIsLoadingABrowser(shouldFetchDebugSession && !readyBrowserSessionId);
+ }, [shouldFetchDebugSession, readyBrowserSessionId, setIsLoadingABrowser]);
+
+ useEffect(() => {
+ return () => {
+ setIsLoadingABrowser(false);
+ };
+ }, [setIsLoadingABrowser]);
+}
+
+export { useBrowserLoadingFlag };
diff --git a/skyvern-frontend/src/store/SettingsStore.test.ts b/skyvern-frontend/src/store/SettingsStore.test.ts
new file mode 100644
index 000000000..c27d9b0e8
--- /dev/null
+++ b/skyvern-frontend/src/store/SettingsStore.test.ts
@@ -0,0 +1,32 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { useSettingsStore } from "./SettingsStore";
+
+const initialState = useSettingsStore.getState();
+
+afterEach(() => {
+ useSettingsStore.setState(initialState, true);
+});
+
+describe("SettingsStore.isLoadingABrowser", () => {
+ it("defaults to false", () => {
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(false);
+ });
+
+ it("flips to true when setIsLoadingABrowser(true) is called", () => {
+ useSettingsStore.getState().setIsLoadingABrowser(true);
+ expect(useSettingsStore.getState().isLoadingABrowser).toBe(true);
+ });
+
+ it("does not affect isUsingABrowser", () => {
+ const before = useSettingsStore.getState().isUsingABrowser;
+ useSettingsStore.getState().setIsLoadingABrowser(true);
+ expect(useSettingsStore.getState().isUsingABrowser).toBe(before);
+ });
+
+ it("does not affect browserSessionId", () => {
+ const before = useSettingsStore.getState().browserSessionId;
+ useSettingsStore.getState().setIsLoadingABrowser(true);
+ expect(useSettingsStore.getState().browserSessionId).toBe(before);
+ });
+});
diff --git a/skyvern-frontend/src/store/SettingsStore.ts b/skyvern-frontend/src/store/SettingsStore.ts
index 57ed62cd0..ab1fe25e7 100644
--- a/skyvern-frontend/src/store/SettingsStore.ts
+++ b/skyvern-frontend/src/store/SettingsStore.ts
@@ -8,6 +8,12 @@ type SettingsStore = {
* be false.
*/
isUsingABrowser: boolean;
+ /**
+ * True from the moment the user has initiated a browser session through to
+ * when `isUsingABrowser` flips true. Owned by the route, not BrowserStream,
+ * so it covers the API-fetch window before BrowserStream mounts (SKY-9777).
+ */
+ isLoadingABrowser: boolean;
/**
* The current browser session ID when a browser is active.
*/
@@ -15,6 +21,7 @@ type SettingsStore = {
organization: string;
setEnvironment: (environment: string) => void;
setIsUsingABrowser: (isUsing: boolean) => void;
+ setIsLoadingABrowser: (isLoading: boolean) => void;
setBrowserSessionId: (browserSessionId: string | null) => void;
setOrganization: (organization: string) => void;
};
@@ -23,10 +30,13 @@ const useSettingsStore = create<SettingsStore>((set) => {
return {
environment: "local",
isUsingABrowser: false,
+ isLoadingABrowser: false,
browserSessionId: null,
organization: "skyvern",
setEnvironment: (environment: string) => set({ environment }),
setIsUsingABrowser: (isUsing: boolean) => set({ isUsingABrowser: isUsing }),
+ setIsLoadingABrowser: (isLoading: boolean) =>
+ set({ isLoadingABrowser: isLoading }),
setBrowserSessionId: (browserSessionId: string | null) =>
set({ browserSessionId }),
setOrganization: (organization: string) => set({ organization }),