The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 22, 08:15 UTC
fix(desktop): preserve host focus on preview pointer presses (#28549)
Yash Singh committed
Nov 1, 2026 at 01:45 UTC
37d7615a91d880c3776d575e1152b9c955104de2
3 files changed
+211
-3
apps/desktop/src/preview/DesktopBrowserHost.ts
+1
-3
@@ -302,9 +302,7 @@ export const make = Effect.gen(function* () {
302
if (tab.relay) return tab.relay;
303
const { webContents, debugger: debuggee } = tab.debuggee;
304
const send = (method: string, params: Record<string, unknown>, sessionId?: string) =>
305
- sessionId === undefined
306
- ? sendPageCommand(webContents, debuggee, method, params)
307
- : debuggee.sendCommand(method, params, sessionId);
305
+ sendPageCommand(webContents, debuggee, method, params, sessionId);
306
const detachedOwners = new Set<string>();
307
/** Viewers and recordings stream; the agent's own sessions never do. */
308
const streamingOwners = new Set<string>();
apps/desktop/src/preview/GuestInput.test.ts
+145
@@ -1,3 +1,5 @@
1
+import * as NodeVM from "node:vm";
2
+
3
import { describe, expect, it, vi } from "vite-plus/test";
4
5
import { sendPageCommand, toKeyboardInputEvents } from "./GuestInput.ts";
@@ -42,6 +44,149 @@ describe("preview guest input", () => {
44
expect(guest.sendCommand).not.toHaveBeenCalledWith("Input.insertText", expect.anything());
45
});
46
47
+ it.each([
48
+ {
49
+ sessionId: undefined,
50
+ method: "Input.dispatchMouseEvent",
51
+ type: "mousePressed",
52
+ outcome: "restore",
53
+ },
54
+ {
55
+ sessionId: "child-frame",
56
+ method: "Input.dispatchMouseEvent",
57
+ type: "mousePressed",
58
+ outcome: "restore",
59
+ },
60
+ {
61
+ sessionId: undefined,
62
+ method: "Input.dispatchTouchEvent",
63
+ type: "touchStart",
64
+ outcome: "restore",
65
+ },
66
+ {
67
+ sessionId: undefined,
68
+ method: "Input.dispatchMouseEvent",
69
+ type: "mousePressed",
70
+ outcome: "other-field",
71
+ },
72
+ {
73
+ sessionId: undefined,
74
+ method: "Input.dispatchMouseEvent",
75
+ type: "mousePressed",
76
+ outcome: "removed",
77
+ },
78
+ {
79
+ sessionId: undefined,
80
+ method: "Input.dispatchMouseEvent",
81
+ type: "mousePressed",
82
+ outcome: "failure",
83
+ },
84
+ ])(
85
+ "preserves host focus for $method in $sessionId with $outcome",
86
+ async ({ sessionId, method, type, outcome }) => {
87
+ const document = { activeElement: {} as object };
88
+ const composer = {
89
+ isConnected: true,
90
+ focus: () => {
91
+ document.activeElement = composer;
92
+ },
93
+ };
94
+ const preview = { tagName: "WEBVIEW", getWebContentsId: () => 7 };
95
+ const otherField = { tagName: "INPUT" };
96
+ document.activeElement = composer;
97
+ const context = NodeVM.createContext({ document });
98
+ const host = {
99
+ isDestroyed: () => false,
100
+ executeJavaScript: async (script: string) => NodeVM.runInContext(script, context),
101
+ };
102
+ const guest = { id: 7, focusedFrame: null, hostWebContents: host };
103
+ const debuggee = {
104
+ sendCommand: async () => {
105
+ document.activeElement = outcome === "other-field" ? otherField : preview;
106
+ if (outcome === "removed") composer.isConnected = false;
107
+ if (outcome === "failure") throw new Error("Pointer failed");
108
+ return {};
109
+ },
110
+ };
111
+ const result = sendPageCommand(
112
+ guest as unknown as Electron.WebContents,
113
+ debuggee as unknown as Electron.Debugger,
114
+ method,
115
+ { type, x: 10, y: 10, button: "left" },
116
+ sessionId,
117
+ );
118
+ if (outcome === "failure") await expect(result).rejects.toThrow("Pointer failed");
119
+ else await result;
120
+ expect(document.activeElement).toBe(
121
+ outcome === "other-field" ? otherField : outcome === "removed" ? preview : composer,
122
+ );
123
+ expect(Object.keys(context)).toEqual(["document"]);
124
+ },
125
+ );
126
+
127
+ it.each([
128
+ {
129
+ method: "Input.dispatchMouseEvent",
130
+ press: "mousePressed",
131
+ release: "mouseReleased",
132
+ failPress: false,
133
+ },
134
+ {
135
+ method: "Input.dispatchTouchEvent",
136
+ press: "touchStart",
137
+ release: "touchEnd",
138
+ failPress: false,
139
+ },
140
+ {
141
+ method: "Input.dispatchMouseEvent",
142
+ press: "mousePressed",
143
+ release: "mouseReleased",
144
+ failPress: true,
145
+ },
146
+ ])(
147
+ "keeps $method releases behind presses waiting for host focus, failed press: $failPress",
148
+ async ({ method, press, release, failPress }) => {
149
+ const captureStarted = Promise.withResolvers<void>();
150
+ const finishCapture = Promise.withResolvers<void>();
151
+ const events: Array<unknown> = [];
152
+ const guest = {
153
+ id: 7,
154
+ focusedFrame: null,
155
+ hostWebContents: {
156
+ isDestroyed: () => false,
157
+ executeJavaScript: async () => {
158
+ captureStarted.resolve();
159
+ await finishCapture.promise;
160
+ },
161
+ },
162
+ };
163
+ const debuggee = {
164
+ sendCommand: async (_method: string, params: Record<string, unknown>) => {
165
+ events.push(params["type"]);
166
+ if (failPress && params["type"] === press) throw new Error("Press failed");
167
+ return {};
168
+ },
169
+ };
170
+ const send = (type: string) =>
171
+ sendPageCommand(
172
+ guest as unknown as Electron.WebContents,
173
+ debuggee as unknown as Electron.Debugger,
174
+ method,
175
+ { type },
176
+ );
177
+ const pressed = send(press);
178
+ await captureStarted.promise;
179
+ const released = send(release);
180
+ finishCapture.resolve();
181
+ const results = await Promise.allSettled([pressed, released]);
182
+ expect(results.map((result) => result.status)).toEqual([
183
+ failPress ? "rejected" : "fulfilled",
184
+ "fulfilled",
185
+ ]);
186
+ expect(events).toEqual([press, release]);
187
+ },
188
+ );
189
+
190
it("refuses input when a cross-site frame holds the unfocused page's focus", async () => {
191
const guest = makeGuest({ focused: false, focusedDocument: false });
192
await expect(guest.send("Input.insertText", { text: "secret" })).rejects.toThrow(
apps/desktop/src/preview/GuestInput.ts
+65
@@ -92,13 +92,78 @@ const evaluate = async (debuggee: Electron.Debugger, expression: string) => {
92
return reply.result?.value;
93
};
94
95
+let focusSequence = 0;
96
+
97
+/** A CDP pointer press focuses the guest's native view even with focus emulation enabled. */
98
+const sendPointerPress = async (
99
+ webContents: Electron.WebContents,
100
+ debuggee: Electron.Debugger,
101
+ method: string,
102
+ params: Record<string, unknown>,
103
+ sessionId: string | undefined,
104
+) => {
105
+ const host = webContents.hostWebContents;
106
+ if (!host || host.isDestroyed() || webContents.focusedFrame) {
107
+ return debuggee.sendCommand(method, params, sessionId);
108
+ }
109
+ const key = JSON.stringify(`__t3PreviewFocus${++focusSequence}`);
110
+ await host.executeJavaScript(`(() => {
111
+ const active = document.activeElement;
112
+ if (!active || active === document.body || active.tagName === "WEBVIEW") return;
113
+ globalThis[${key}] = () => {
114
+ delete globalThis[${key}];
115
+ const current = document.activeElement;
116
+ if (active.isConnected && current?.tagName === "WEBVIEW" &&
117
+ current.getWebContentsId() === ${webContents.id}) active.focus({ preventScroll: true });
118
+ };
119
+ })()`);
120
+ try {
121
+ return await debuggee.sendCommand(method, params, sessionId);
122
+ } finally {
123
+ if (!host.isDestroyed()) {
124
+ await host.executeJavaScript(`globalThis[${key}]?.()`);
125
+ }
126
+ }
127
+};
128
+
129
+const pointerCommands = new WeakMap<Electron.WebContents, Promise<unknown>>();
130
+
131
+/** Focus capture crosses processes; later pointer events must not overtake the press. */
132
+const sendPointerCommand = async (
133
+ webContents: Electron.WebContents,
134
+ debuggee: Electron.Debugger,
135
+ method: string,
136
+ params: Record<string, unknown>,
137
+ sessionId: string | undefined,
138
+) => {
139
+ const previous = pointerCommands.get(webContents) ?? Promise.resolve();
140
+ const current = previous
141
+ .catch(() => {})
142
+ .then(() =>
143
+ params["type"] === "mousePressed" || params["type"] === "touchStart"
144
+ ? sendPointerPress(webContents, debuggee, method, params, sessionId)
145
+ : debuggee.sendCommand(method, params, sessionId),
146
+ );
147
+ pointerCommands.set(webContents, current);
148
+ try {
149
+ return await current;
150
+ } finally {
151
+ if (pointerCommands.get(webContents) === current) pointerCommands.delete(webContents);
152
+ }
153
+};
154
+
155
/** Sends one command to the guest's page, keeping reloads and input inside it. */
156
export const sendPageCommand = async (
157
webContents: Electron.WebContents,
158
debuggee: Electron.Debugger,
159
method: string,
160
params: Record<string, unknown>,
161
+ sessionId?: string,
162
): Promise<unknown> => {
163
+ if (method === "Input.dispatchMouseEvent" || method === "Input.dispatchTouchEvent") {
164
+ return sendPointerCommand(webContents, debuggee, method, params, sessionId);
165
+ }
166
+ if (sessionId !== undefined) return debuggee.sendCommand(method, params, sessionId);
167
// Electron's debugger routes Page.reload on a webview to its embedder window.
168
if (method === "Page.reload") {
169
if (params["ignoreCache"] === true) webContents.reloadIgnoringCache();