Skip to content

Commit 798e945

Browse files
t3dotggclaude
andauthored
fix(preview): agent browser clicks no longer steal your composer focus (pingdotgg#15008)
Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
1 parent 63f74e2 commit 798e945

3 files changed

Lines changed: 225 additions & 3 deletions

File tree

‎apps/web/src/components/preview/PreviewAutomationHosts.tsx‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,7 @@ import {
9090
resolvePreviewAutomationTarget,
9191
} from "./previewAutomationTarget";
9292
import { resolveHostWaitBudgetMs, waitForHostReadiness } from "./previewAutomationHostBudget";
93+
import { runPreviewClickKeepingHostFocus } from "./previewClickFocus";
9394
import { isPreviewViewportReady } from "./previewViewportReadiness";
9495
import { shouldRollbackPreviewViewport } from "./previewViewportRollback";
9596

@@ -686,9 +687,11 @@ function PreviewAutomationHost(props: { readonly environmentId: EnvironmentId })
686687
}
687688
case "click": {
688689
const ready = await requireReadyTab();
689-
return await ready.bridge.automation.click(
690-
ready.runtimeTabId,
691-
request.input as Parameters<typeof ready.bridge.automation.click>[1],
690+
return await runPreviewClickKeepingHostFocus(ready.runtimeTabId, () =>
691+
ready.bridge.automation.click(
692+
ready.runtimeTabId,
693+
request.input as Parameters<typeof ready.bridge.automation.click>[1],
694+
),
692695
);
693696
}
694697
case "type": {
Lines changed: 152 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,152 @@
1+
// @vitest-environment jsdom
2+
3+
import { afterEach, describe, expect, it } from "vite-plus/test";
4+
5+
import { runPreviewClickKeepingHostFocus } from "./previewClickFocus";
6+
7+
const TAB = "runtime-tab";
8+
9+
const mount = (tagName: string, previewTab?: string) => {
10+
const element = document.createElement(tagName);
11+
element.tabIndex = -1;
12+
if (previewTab) element.setAttribute("data-preview-tab", previewTab);
13+
document.body.append(element);
14+
return element;
15+
};
16+
17+
afterEach(() => {
18+
document.body.replaceChildren();
19+
});
20+
21+
describe("runPreviewClickKeepingHostFocus", () => {
22+
it("gives focus back to the composer after the click focuses the page", async () => {
23+
const composer = mount("textarea");
24+
const webview = mount("webview", TAB);
25+
composer.focus();
26+
27+
const result = await runPreviewClickKeepingHostFocus(TAB, async () => {
28+
webview.focus();
29+
return "clicked";
30+
});
31+
32+
expect(result).toBe("clicked");
33+
expect(document.activeElement).toBe(composer);
34+
});
35+
36+
it("gives focus back when the user's typing interrupts the click", async () => {
37+
const composer = mount("textarea");
38+
const webview = mount("webview", TAB);
39+
composer.focus();
40+
const interrupted = new Error("PreviewAutomationControlInterruptedError");
41+
42+
await expect(
43+
runPreviewClickKeepingHostFocus(TAB, async () => {
44+
webview.focus();
45+
throw interrupted;
46+
}),
47+
).rejects.toBe(interrupted);
48+
49+
expect(document.activeElement).toBe(composer);
50+
});
51+
52+
it("gives focus back once overlapping clicks in two tabs finish", async () => {
53+
const composer = mount("textarea");
54+
const first = mount("webview", TAB);
55+
const second = mount("webview", "other-tab");
56+
composer.focus();
57+
let finishSecond = () => {};
58+
59+
const firstClick = runPreviewClickKeepingHostFocus(TAB, async () => {
60+
first.focus();
61+
});
62+
// Starts while the first click holds focus in its page, and finishes last.
63+
const secondClick = runPreviewClickKeepingHostFocus("other-tab", async () => {
64+
second.focus();
65+
await new Promise<void>((resolve) => {
66+
finishSecond = resolve;
67+
});
68+
});
69+
await firstClick;
70+
finishSecond();
71+
await secondClick;
72+
73+
expect(document.activeElement).toBe(composer);
74+
});
75+
76+
it("keeps the user's page when overlapping clicks finish in reverse order", async () => {
77+
const first = mount("webview", TAB);
78+
const second = mount("webview", "other-tab");
79+
second.focus();
80+
let finishFirst = () => {};
81+
82+
const firstClick = runPreviewClickKeepingHostFocus(TAB, async () => {
83+
first.focus();
84+
await new Promise<void>((resolve) => {
85+
finishFirst = resolve;
86+
});
87+
});
88+
// Starts while the first click holds focus in its page, and finishes first.
89+
await runPreviewClickKeepingHostFocus("other-tab", async () => {
90+
second.focus();
91+
});
92+
finishFirst();
93+
await firstClick;
94+
95+
expect(document.activeElement).toBe(second);
96+
});
97+
98+
it("ignores a click that never finishes", async () => {
99+
const composer = mount("textarea");
100+
const stuck = mount("webview", "stuck-tab");
101+
const webview = mount("webview", TAB);
102+
const other = mount("webview", "other-tab");
103+
composer.focus();
104+
105+
// A click queued behind a page promise that never settles.
106+
void runPreviewClickKeepingHostFocus("stuck-tab", () => new Promise<never>(() => {}));
107+
await runPreviewClickKeepingHostFocus(TAB, async () => {
108+
webview.focus();
109+
});
110+
expect(document.activeElement).toBe(composer);
111+
112+
// The user opens the stuck tab's page themselves.
113+
stuck.focus();
114+
await runPreviewClickKeepingHostFocus("other-tab", async () => {
115+
other.focus();
116+
});
117+
expect(document.activeElement).toBe(stuck);
118+
});
119+
120+
it("leaves no focus in the page when the composer can no longer take focus", async () => {
121+
const composer = mount("div");
122+
const webview = mount("webview", TAB);
123+
composer.focus();
124+
125+
await runPreviewClickKeepingHostFocus(TAB, async () => {
126+
webview.focus();
127+
// Like the editor going read-only for an approval request.
128+
composer.removeAttribute("tabindex");
129+
});
130+
131+
expect(document.activeElement).toBe(document.body);
132+
});
133+
134+
it("leaves no focus in the page when nothing in the app had focus", async () => {
135+
const webview = mount("webview", TAB);
136+
137+
await runPreviewClickKeepingHostFocus(TAB, async () => {
138+
webview.focus();
139+
});
140+
141+
expect(document.activeElement).toBe(document.body);
142+
});
143+
144+
it("keeps focus in the page when the user was already typing there", async () => {
145+
const webview = mount("webview", TAB);
146+
webview.focus();
147+
148+
await runPreviewClickKeepingHostFocus(TAB, async () => undefined);
149+
150+
expect(document.activeElement).toBe(webview);
151+
});
152+
});
Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
interface PreviewClick {
2+
readonly runtimeTabId: string;
3+
readonly order: number;
4+
previous: Element | null;
5+
}
6+
7+
// Agent clicks can overlap across tabs and threads.
8+
const inFlightClicks = new Set<PreviewClick>();
9+
let nextClickOrder = 0;
10+
11+
const focusedPreviewTab = (element: Element | null): string | null =>
12+
element?.localName === "webview" ? element.getAttribute("data-preview-tab") : null;
13+
14+
const restoreHostFocus = ({ runtimeTabId, previous }: PreviewClick): void => {
15+
const current = document.activeElement;
16+
if (
17+
!(current instanceof HTMLElement) ||
18+
current === previous ||
19+
focusedPreviewTab(current) !== runtimeTabId
20+
) {
21+
return;
22+
}
23+
if (previous instanceof HTMLElement && previous.isConnected && previous !== document.body) {
24+
previous.focus({ preventScroll: true });
25+
}
26+
// The previous element may no longer take focus, like a composer that was
27+
// disabled during the click. Never leave focus in the page.
28+
if (document.activeElement === current) current.blur();
29+
};
30+
31+
/**
32+
* Runs an agent click in a preview tab and hands keyboard focus back to the
33+
* host page afterwards.
34+
*
35+
* The desktop dispatches the click as a CDP mouse press, which focuses the
36+
* guest page, and nothing gives that focus back. The user's next keystrokes
37+
* then go into the page, even when its tab is hidden or belongs to another
38+
* thread. Only the host document knows what had focus before the click, so
39+
* the restore happens here and not in the desktop main process.
40+
*/
41+
export async function runPreviewClickKeepingHostFocus<A>(
42+
runtimeTabId: string,
43+
click: () => Promise<A>,
44+
): Promise<A> {
45+
const entry: PreviewClick = {
46+
runtimeTabId,
47+
order: nextClickOrder++,
48+
previous: document.activeElement,
49+
};
50+
inFlightClicks.add(entry);
51+
try {
52+
return await click();
53+
} finally {
54+
// Also runs when the click fails: a keystroke that reaches the page after
55+
// the press counts as human input and fails the click as interrupted.
56+
inFlightClicks.delete(entry);
57+
// A click that started while this one held focus in its page saw that page
58+
// as what had focus. Hand it this click's target instead. A click that never
59+
// finishes never gets here, so it cannot override where the user goes later.
60+
for (const other of inFlightClicks) {
61+
if (other.order > entry.order && focusedPreviewTab(other.previous) === runtimeTabId) {
62+
other.previous = entry.previous;
63+
}
64+
}
65+
restoreHostFocus(entry);
66+
}
67+
}

0 commit comments

Comments
 (0)