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, 12:00 UTC
fix(server): streamed clicks no longer wait behind stale hovers (#22739)
Rookmate committed
Oct 31, 2026 at 00:42 UTC
e94c3a72ca25bf5f442d5c896752b6685ed10ebf
4 files changed
+348
-3
apps/server/src/preview/ServerBrowser.test.ts
+127
@@ -977,6 +977,133 @@ it.live(
977
).pipe(Effect.provide(layer)),
978
);
979
980
+it.effect.each([
981
+ {
982
+ name: "hover burst before a click",
983
+ inputs: [
984
+ ...Array.from({ length: 120 }, (_, x) => ({
985
+ type: "mouse",
986
+ action: "move",
987
+ x,
988
+ buttons: 0,
989
+ button: "none",
990
+ })),
991
+ { type: "mouse", action: "down", x: 119, buttons: 1, button: "left" },
992
+ { type: "mouse", action: "up", x: 119, buttons: 0, button: "left" },
993
+ ],
994
+ expected: [
995
+ { type: "mouseMoved", x: -1 },
996
+ { type: "mouseMoved", x: 119 },
997
+ { type: "mousePressed", x: 119 },
998
+ { type: "mouseReleased", x: 119 },
999
+ ],
1000
+ },
1001
+ {
1002
+ name: "modifier changes and drag points",
1003
+ inputs: [
1004
+ { type: "mouse", action: "move", x: 1, buttons: 0, button: "none" },
1005
+ { type: "mouse", action: "move", x: 2, buttons: 0, button: "none", modifiers: 2 },
1006
+ { type: "mouse", action: "move", x: 3, buttons: 0, button: "none", modifiers: 2 },
1007
+ { type: "mouse", action: "down", x: 3, buttons: 1, button: "left" },
1008
+ { type: "mouse", action: "move", x: 4, buttons: 1, button: "left" },
1009
+ { type: "mouse", action: "move", x: 5, buttons: 1, button: "left" },
1010
+ { type: "mouse", action: "up", x: 5, buttons: 0, button: "left" },
1011
+ ],
1012
+ expected: [
1013
+ { type: "mouseMoved", x: -1 },
1014
+ { type: "mouseMoved", x: 1, modifiers: 0 },
1015
+ { type: "mouseMoved", x: 3, modifiers: 2 },
1016
+ { type: "mousePressed", x: 3 },
1017
+ { type: "mouseMoved", x: 4 },
1018
+ { type: "mouseMoved", x: 5 },
1019
+ { type: "mouseReleased", x: 5 },
1020
+ ],
1021
+ },
1022
+ {
1023
+ name: "wheel and keyboard boundaries",
1024
+ inputs: [
1025
+ { type: "mouse", action: "move", x: 1, buttons: 0, button: "none" },
1026
+ { type: "wheel", x: 1, deltaY: 20 },
1027
+ { type: "wheel", x: 1, deltaY: 30 },
1028
+ { type: "mouse", action: "move", x: 2, buttons: 0, button: "none" },
1029
+ { type: "key", action: "down", key: "a", code: "KeyA", text: "a" },
1030
+ { type: "mouse", action: "move", x: 3, buttons: 0, button: "none" },
1031
+ ],
1032
+ expected: [
1033
+ { type: "mouseMoved", x: -1 },
1034
+ { type: "mouseMoved", x: 1 },
1035
+ { type: "mouseWheel", deltaY: 20 },
1036
+ { type: "mouseWheel", deltaY: 30 },
1037
+ { type: "mouseMoved", x: 2 },
1038
+ { type: "keyDown", key: "a" },
1039
+ { type: "mouseMoved", x: 3 },
1040
+ ],
1041
+ },
1042
+ {
1043
+ name: "text, navigation and resize boundaries",
1044
+ inputs: [
1045
+ { type: "mouse", action: "move", x: 1, buttons: 0, button: "none" },
1046
+ { type: "text", text: "typed" },
1047
+ { type: "mouse", action: "move", x: 2, buttons: 0, button: "none" },
1048
+ { type: "navigate", url: "http://localhost:5173/next" },
1049
+ { type: "mouse", action: "move", x: 3, buttons: 0, button: "none" },
1050
+ { type: "resize", width: 640, height: 480 },
1051
+ { type: "mouse", action: "move", x: 4, buttons: 0, button: "none" },
1052
+ ],
1053
+ expected: [
1054
+ { type: "mouseMoved", x: -1 },
1055
+ { type: "mouseMoved", x: 1 },
1056
+ { text: "typed" },
1057
+ { type: "mouseMoved", x: 2 },
1058
+ { type: "mouseMoved", x: 3 },
1059
+ { type: "mouseMoved", x: 4 },
1060
+ ],
1061
+ },
1062
+ {
1063
+ name: "ambiguous button fields",
1064
+ inputs: [
1065
+ { type: "mouse", action: "move", x: 1, button: "none" },
1066
+ { type: "mouse", action: "move", x: 2, button: "none" },
1067
+ { type: "mouse", action: "move", x: 3, buttons: 0 },
1068
+ { type: "mouse", action: "move", x: 4, buttons: 0 },
1069
+ ],
1070
+ expected: [-1, 1, 2, 3, 4].map((x) => ({ type: "mouseMoved", x })),
1071
+ },
1072
+])("orders streamed input correctly for $name", (testCase) =>
1073
+ Effect.scoped(
1074
+ Effect.gen(function* () {
1075
+ const { browser, tabId } = yield* ready;
1076
+ const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
1077
+ yield* viewer.input({ type: "takeControl" });
1078
+ const session = contexts[0]!.sessions.at(-1)!;
1079
+ const send = session.send.getMockImplementation()!;
1080
+ const started = Promise.withResolvers<void>();
1081
+ const finish = Promise.withResolvers<void>();
1082
+ yield* Effect.addFinalizer(() => Effect.sync(() => finish.resolve()));
1083
+ session.send.mockClear();
1084
+ session.send.mockImplementationOnce(async (method, input) => {
1085
+ started.resolve();
1086
+ await finish.promise;
1087
+ return send(method, input);
1088
+ });
1089
+ const running = yield* viewer
1090
+ .input({ type: "mouse", action: "move", x: -1, button: "none", buttons: 0 })
1091
+ .pipe(Effect.forkScoped({ startImmediately: true }));
1092
+ yield* Effect.promise(() => started.promise);
1093
+ const waiting = yield* Effect.forEach(testCase.inputs, (input) =>
1094
+ viewer.input(input).pipe(Effect.forkScoped({ startImmediately: true })),
1095
+ );
1096
+ finish.resolve();
1097
+ yield* Effect.forEach([running, ...waiting], Fiber.join);
1098
+ const dispatched = session.send.mock.calls.flatMap(([method, input]) =>
1099
+ method.startsWith("Input.") ? [input] : [],
1100
+ );
1101
+ expect(dispatched).toHaveLength(testCase.expected.length);
1102
+ expect(dispatched).toMatchObject(testCase.expected);
1103
+ }),
1104
+ ).pipe(Effect.provide(layer)),
1105
+);
1106
+
1107
it.live("only the controlling viewer's copy and cut keys reach its clipboard", () =>
1108
Effect.scoped(
1109
Effect.gen(function* () {
apps/server/src/preview/ServerBrowser.ts
+11
-3
@@ -2550,9 +2550,17 @@ const make = Effect.gen(function* () {
2550
: {}),
2551
});
2552
} else {
2553
- await tab.control.human(viewer.id, () =>
2554
- dispatchViewerInput(tab, session, viewer, message),
2555
- );
2553
+ const dispatch = () => dispatchViewerInput(tab, session, viewer, message);
2554
+ if (
2555
+ message.type === "mouse" &&
2556
+ message.action === "move" &&
2557
+ message.button === "none" &&
2558
+ message.buttons === 0
2559
+ ) {
2560
+ await tab.control.humanLatest(viewer.id, `hover:${modifiersOf(message)}`, dispatch);
2561
+ } else {
2562
+ await tab.control.human(viewer.id, dispatch);
2563
+ }
2564
}
2565
} catch {
2566
broadcastControl(tab);
apps/server/src/preview/SessionControl.test.ts
+187
@@ -3,6 +3,193 @@ import { describe, expect, it } from "vite-plus/test";
3
import { BrowserControlInterrupted, SessionControl } from "./SessionControl.ts";
4
5
describe("SessionControl", () => {
6
+ it("replaces waiting hover work without changing the running action or delaying the following click", async () => {
7
+ const control = new SessionControl("agent");
8
+ await control.take("viewer");
9
+ const started = Promise.withResolvers<void>();
10
+ const finish = Promise.withResolvers<void>();
11
+ const events: Array<number | string> = [];
12
+ const running = control.humanLatest("viewer", "hover:0", async () => {
13
+ events.push("running");
14
+ started.resolve();
15
+ await finish.promise;
16
+ });
17
+ await started.promise;
18
+ const moves = Array.from({ length: 120 }, (_, position) =>
19
+ control.humanLatest("viewer", "hover:0", async () => {
20
+ events.push(position);
21
+ }),
22
+ );
23
+ const click = control.human("viewer", async () => {
24
+ events.push("click");
25
+ });
26
+ finish.resolve();
27
+ await Promise.all([running, ...moves, click]);
28
+ expect(events).toEqual(["running", 119, "click"]);
29
+ });
30
+
31
+ it.each(["human", "system", "modifiers"] as const)(
32
+ "does not merge waiting hover work across a %s action",
33
+ async (barrier) => {
34
+ const control = new SessionControl("agent");
35
+ await control.take("viewer");
36
+ const finish = Promise.withResolvers<void>();
37
+ const events: string[] = [];
38
+ const running = control.human("viewer", () => finish.promise);
39
+ const before = control.humanLatest("viewer", "hover:0", async () => {
40
+ events.push("before");
41
+ });
42
+ const recordBarrier = async () => {
43
+ events.push("barrier");
44
+ };
45
+ const between =
46
+ barrier === "modifiers"
47
+ ? control.humanLatest("viewer", "hover:2", recordBarrier)
48
+ : barrier === "system"
49
+ ? control.system(recordBarrier)
50
+ : control.human("viewer", recordBarrier);
51
+ const after = control.humanLatest("viewer", "hover:0", async () => {
52
+ events.push("after");
53
+ });
54
+ finish.resolve();
55
+ await Promise.all([running, before, between, after]);
56
+ expect(events).toEqual(["before", "barrier", "after"]);
57
+ },
58
+ );
59
+
60
+ it("does not let another viewer replace or split the owner's waiting hover", async () => {
61
+ const control = new SessionControl("agent");
62
+ await control.take("viewer");
63
+ const finish = Promise.withResolvers<void>();
64
+ const events: string[] = [];
65
+ const running = control.human("viewer", () => finish.promise);
66
+ const stale = control.humanLatest("viewer", "hover", async () => {
67
+ events.push("stale");
68
+ });
69
+ await expect(
70
+ control.humanLatest("other", "hover", async () => {
71
+ events.push("other");
72
+ }),
73
+ ).rejects.toThrow(BrowserControlInterrupted);
74
+ const latest = control.humanLatest("viewer", "hover", async () => {
75
+ events.push("latest");
76
+ });
77
+ finish.resolve();
78
+ await Promise.all([running, stale, latest]);
79
+ expect(events).toEqual(["latest"]);
80
+ });
81
+
82
+ it.each(["release", "disconnect"] as const)(
83
+ "does not revive waiting hover work after %s and retaking control",
84
+ async (handoff) => {
85
+ const control = new SessionControl("agent");
86
+ await control.take("viewer");
87
+ const started = Promise.withResolvers<void>();
88
+ const finish = Promise.withResolvers<void>();
89
+ const events: string[] = [];
90
+ const running = control.human("viewer", () => {
91
+ started.resolve();
92
+ return finish.promise;
93
+ });
94
+ await started.promise;
95
+ const stale = expect(
96
+ control.humanLatest("viewer", "hover", async () => {
97
+ events.push("stale");
98
+ }),
99
+ ).rejects.toThrow(BrowserControlInterrupted);
100
+ const released = control[handoff]("viewer");
101
+ const retaken = control.take("viewer");
102
+ const fresh = control.humanLatest("viewer", "hover", async () => {
103
+ events.push("fresh");
104
+ });
105
+ const latest = control.humanLatest("viewer", "hover", async () => {
106
+ events.push("latest");
107
+ });
108
+ finish.resolve();
109
+ await Promise.all([running, stale, released, retaken, fresh, latest]);
110
+ expect(events).toEqual(["latest"]);
111
+ },
112
+ );
113
+
114
+ it("rejects every caller of a merged hover when the tab closes", async () => {
115
+ const control = new SessionControl("agent");
116
+ await control.take("viewer");
117
+ const started = Promise.withResolvers<void>();
118
+ const finish = Promise.withResolvers<void>();
119
+ const events: string[] = [];
120
+ const running = control.human("viewer", () => {
121
+ started.resolve();
122
+ return finish.promise;
123
+ });
124
+ await started.promise;
125
+ const waiting = [1, 2].map((position) =>
126
+ expect(
127
+ control.humanLatest("viewer", "hover", async () => {
128
+ events.push(`hover ${position}`);
129
+ }),
130
+ ).rejects.toThrow("closed"),
131
+ );
132
+ const closed = control.close();
133
+ await expect(
134
+ control.humanLatest("viewer", "hover", async () => {
135
+ events.push("after close");
136
+ }),
137
+ ).rejects.toThrow("closed");
138
+ finish.resolve();
139
+ await Promise.all([running, ...waiting, closed]);
140
+ expect(events).toEqual([]);
141
+ });
142
+
143
+ it("shares a merged dispatch failure and accepts fresh hover work afterwards", async () => {
144
+ const control = new SessionControl("agent");
145
+ await control.take("viewer");
146
+ const finish = Promise.withResolvers<void>();
147
+ const events: string[] = [];
148
+ const running = control.human("viewer", () => finish.promise);
149
+ const first = expect(
150
+ control.humanLatest("viewer", "hover", async () => {
151
+ events.push("superseded");
152
+ }),
153
+ ).rejects.toThrow("dispatch failed");
154
+ const last = expect(
155
+ control.humanLatest("viewer", "hover", async () => {
156
+ throw new Error("dispatch failed");
157
+ }),
158
+ ).rejects.toThrow("dispatch failed");
159
+ finish.resolve();
160
+ await Promise.all([running, first, last]);
161
+ await control.humanLatest("viewer", "hover", async () => {
162
+ events.push("recovered");
163
+ });
164
+ expect(events).toEqual(["recovered"]);
165
+ });
166
+
167
+ it("waits for tracked navigation before dispatching the latest human hover", async () => {
168
+ const control = new SessionControl("agent");
169
+ await control.take("viewer");
170
+ const committed = Promise.withResolvers<void>();
171
+ const events: string[] = [];
172
+ const navigation = control.human("viewer", async () => {
173
+ control.track(
174
+ committed.promise.then(() => {
175
+ events.push("navigation committed");
176
+ }),
177
+ );
178
+ return "started";
179
+ });
180
+ const first = control.humanLatest("viewer", "hover", async () => {
181
+ events.push("superseded");
182
+ });
183
+ const latest = control.humanLatest("viewer", "hover", async () => {
184
+ events.push("latest");
185
+ });
186
+ await expect(navigation).resolves.toBe("started");
187
+ expect(events).toEqual([]);
188
+ committed.resolve();
189
+ await Promise.all([first, latest]);
190
+ expect(events).toEqual(["navigation committed", "latest"]);
191
+ });
192
+
193
it("returns an action result before tracked navigation but drains it before already queued actions", async () => {
194
const control = new SessionControl("agent");
195
const committed = Promise.withResolvers<void>();
apps/server/src/preview/SessionControl.ts
+23
@@ -22,6 +22,10 @@ export class SessionControl {
22
readonly agentId: string | null;
23
private readonly onGenerationChange: () => void;
24
private tail: Promise<unknown> = Promise.resolve();
25
+ private latestHuman: {
26
+ entry: { viewerId: string; key: string; run: () => Promise<void> };
27
+ result: Promise<void>;
28
+ } | null = null;
29
private pending: Promise<void> = Promise.resolve();
30
private readonly handoff = new Set<Promise<void>>();
31
private owner: string | null = null;
@@ -42,6 +46,7 @@ export class SessionControl {
46
}
47
48
private enqueue<A>(run: () => Promise<A>): Promise<A> {
49
+ this.latestHuman = null;
50
const result = this.tail.then(run);
51
this.tail = result.then(
52
() => this.pending,
@@ -68,6 +73,7 @@ export class SessionControl {
73
}
74
75
private changeOwner(owner: string | null) {
76
+ this.latestHuman = null;
77
this.owner = owner;
78
this.epoch++;
79
this.onGenerationChange();
@@ -128,6 +134,23 @@ export class SessionControl {
134
return this.action(() => this.owner === viewerId, run);
135
}
136
137
+ /** Replace only adjacent waiting work; the running action and intervening actions keep their order. */
138
+ humanLatest(viewerId: string, key: string, run: () => Promise<void>): Promise<void> {
139
+ if (this.closed || this.owner !== viewerId) return this.human(viewerId, run);
140
+ const latest = this.latestHuman;
141
+ if (latest?.entry.viewerId === viewerId && latest.entry.key === key) {
142
+ latest.entry.run = run;
143
+ return latest.result;
144
+ }
145
+ const entry = { viewerId, key, run };
146
+ const result = this.human(viewerId, async () => {
147
+ if (this.latestHuman?.entry === entry) this.latestHuman = null;
148
+ await entry.run();
149
+ });
150
+ this.latestHuman = { entry, result };
151
+ return result;
152
+ }
153
+
154
async take(viewerId: string) {
155
this.assertOpen();
156
if (this.owner !== null && this.owner !== viewerId) {