Skip to content

Commit 08c7095

Browse files
PR Batch Testerclaude
andcommitted
fix(server): keep only the desktop viewport recovery a real path needs
Desktop size reads now run one at a time per tab, and callers that arrive during a read share the next one, so reads stay ordered without counters and a burst of resizes costs two reads. The read timeout runs on the Effect clock. Dropped as over-built: the dialog shortcut and remeasure (the read timeout already covers a dialog-blocked read), the ended flag (broadcastViewport now skips a closing tab, the only late pusher this PR added), and retaining notifications across a backlog replacement, which main never did. The two tests run as it.effect and cover what remains: ordered burst reads, the timeout and late answer, failed and 0x0 reads, retained control and viewport in both directions, the picker after a resize, reconnect after a late resize, and acknowledgement of every dropped frame. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent 620986a commit 08c7095

2 files changed

Lines changed: 144 additions & 129 deletions

File tree

‎apps/server/src/preview/ServerBrowser.test.ts‎

Lines changed: 116 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ import * as Path from "effect/Path";
2424
import * as PubSub from "effect/PubSub";
2525
import * as Queue from "effect/Queue";
2626
import * as Stream from "effect/Stream";
27+
import * as TestClock from "effect/testing/TestClock";
2728
import type { BrowserContext, Page } from "playwright-core";
2829
import { beforeEach, expect, vi } from "vite-plus/test";
2930

@@ -389,13 +390,36 @@ const viewerInput = (tabId: string, canOperate: boolean) => ({
389390
maxHeight: 800,
390391
quality: 70,
391392
});
392-
const stallViewer = (
393-
viewer: ServerBrowser.ServerBrowserViewer,
394-
item: ServerBrowser.ServerBrowserViewerOutput,
395-
) => {
393+
/** Fills a viewer's output with frames; resolves once every one of them is acknowledged. */
394+
const stallViewer = (viewer: ServerBrowser.ServerBrowserViewer) => {
396395
const output = viewer.output as unknown as Queue.Queue<ServerBrowser.ServerBrowserViewerOutput>;
397-
while (Queue.offerUnsafe(output, item));
396+
const acked = Promise.withResolvers<void>();
397+
let unacked = 0;
398+
const ack = Effect.sync(() => {
399+
if (--unacked === 0) acked.resolve();
400+
});
401+
while (Queue.offerUnsafe(output, { _tag: "frame", data: Buffer.alloc(0), ack })) unacked++;
402+
return Effect.promise(() => acked.promise);
398403
};
404+
const viewportSizes = (items: ReadonlyArray<ServerBrowser.ServerBrowserViewerOutput>) =>
405+
items.flatMap((item) => (item._tag === "viewport" ? [`${item.width}x${item.height}`] : []));
406+
const openDesktopViewer = Effect.gen(function* () {
407+
const browser = yield* ServerBrowser.ServerBrowser;
408+
const manager = yield* Manager.PreviewManager;
409+
desktopRendersNext = true;
410+
const { tabId } = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" });
411+
const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
412+
const context = desktopConnections[0]!.context;
413+
const cdp = context.sessions[0]!;
414+
const resize = (width: number, height: number) => {
415+
Object.assign(context.cssViewport, { width, height });
416+
return Effect.promise(() => cdp.emitAsync("Page.frameResized"));
417+
};
418+
// Ready once the size measured on attach and on a first resize both reached the viewer.
419+
yield* resize(1920, 1080);
420+
expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual(["1920x1080", "1920x1080"]);
421+
return { tabId, viewer, context, cdp, resize };
422+
});
399423

400424
beforeEach(() => {
401425
contexts.length = 0;
@@ -1175,71 +1199,103 @@ it.live("only the current controller can answer a file picker", () =>
11751199
).pipe(Effect.provide(layer)),
11761200
);
11771201

1178-
it.live("desktop viewers get the page's CSS size and keep the last one a read cannot measure", () =>
1179-
Effect.scoped(
1180-
Effect.gen(function* () {
1181-
const browser = yield* ServerBrowser.ServerBrowser;
1182-
const manager = yield* Manager.PreviewManager;
1183-
const broker = yield* Broker.PreviewAutomationBroker;
1184-
yield* Effect.yieldNow;
1185-
desktopRendersNext = true;
1186-
const opened = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" });
1187-
const viewer = yield* browser.attachViewer(viewerInput(opened.tabId, true));
1188-
const context = desktopConnections[0]!.context;
1189-
const cdp = context.sessions[0]!;
1190-
Object.assign(context.cssViewport, { width: 1000, height: 600 });
1191-
cdp.send.mockClear();
1192-
// A burst of resizes measures the page once more after the read in flight.
1193-
yield* Effect.promise(() =>
1194-
Promise.all([1, 2, 3].map(() => cdp.emitAsync("Page.frameResized"))),
1195-
);
1196-
expect(yield* Queue.takeAll(viewer.output)).toContainEqual({
1197-
_tag: "viewport",
1198-
width: 1000,
1199-
height: 600,
1200-
});
1201-
const reads = cdp.send.mock.calls.filter(
1202-
([method, input]) =>
1203-
method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 9,
1204-
);
1205-
expect(reads).toHaveLength(2);
1206-
// A hidden webview measures 0x0.
1207-
Object.assign(context.cssViewport, { width: 0, height: 0 });
1208-
expect(
1209-
yield* broker.invoke<PreviewAutomationStatus>({
1210-
scope,
1211-
operation: "status",
1212-
input: {},
1213-
tabId: PreviewTabId.make(opened.tabId),
1214-
}),
1215-
).toMatchObject({ viewport: { width: 1000, height: 600 } });
1216-
}),
1217-
).pipe(Effect.provide(layer)),
1202+
it.effect(
1203+
"desktop viewers get the page's CSS size and keep the last one a read cannot measure",
1204+
() =>
1205+
Effect.scoped(
1206+
Effect.gen(function* () {
1207+
const { viewer, cdp } = yield* openDesktopViewer;
1208+
// Each page size read waits here for its answer.
1209+
const reads = yield* Queue.unbounded<PromiseWithResolvers<Record<string, unknown>>>();
1210+
const send = cdp.send.getMockImplementation()!;
1211+
cdp.send.mockImplementation((method, input) => {
1212+
if (method !== "Runtime.evaluate" || (input as { contextId?: number }).contextId !== 9)
1213+
return send(method, input);
1214+
const read = Promise.withResolvers<Record<string, unknown>>();
1215+
Queue.offerUnsafe(reads, read);
1216+
return read.promise;
1217+
});
1218+
const answer = (width: number, height: number) => ({
1219+
result: { value: { width, height } },
1220+
});
1221+
const resized = () => cdp.emitAsync("Page.frameResized");
1222+
// Resizes during a read share one more read, so the newest size arrives last.
1223+
const first = resized();
1224+
const firstRead = yield* Queue.take(reads);
1225+
const burst = Promise.all([resized(), resized()]);
1226+
firstRead.resolve(answer(800, 500));
1227+
(yield* Queue.take(reads)).resolve(answer(1000, 600));
1228+
expect(yield* Queue.size(reads)).toBe(0);
1229+
yield* Effect.promise(() => Promise.all([first, burst]));
1230+
expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual([
1231+
"800x500",
1232+
"1000x600",
1233+
"1000x600",
1234+
]);
1235+
// A dialog blocks page script, so a read that never answers gives up.
1236+
const blocked = resized();
1237+
const stuck = yield* Queue.take(reads);
1238+
yield* TestClock.adjust("1 second");
1239+
yield* Effect.promise(() => blocked);
1240+
// Its late answer, a read a navigation breaks and a hidden webview keep the last size.
1241+
stuck.resolve(answer(100, 100));
1242+
const navigated = resized();
1243+
(yield* Queue.take(reads)).reject(new Error("Cannot find context with specified id"));
1244+
yield* Effect.promise(() => navigated);
1245+
const hidden = resized();
1246+
(yield* Queue.take(reads)).resolve(answer(0, 0));
1247+
yield* Effect.promise(() => hidden);
1248+
expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual([
1249+
"1000x600",
1250+
"1000x600",
1251+
"1000x600",
1252+
]);
1253+
}),
1254+
).pipe(Effect.provide(layer)),
12181255
);
12191256

1220-
it.live("a stalled desktop viewer still gets its size, control and reconnect", () =>
1257+
it.effect("a stalled desktop viewer still gets its size, control and reconnect", () =>
12211258
Effect.scoped(
12221259
Effect.gen(function* () {
1223-
const browser = yield* ServerBrowser.ServerBrowser;
1224-
const manager = yield* Manager.PreviewManager;
1225-
yield* Effect.yieldNow;
1226-
desktopRendersNext = true;
1227-
const opened = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" });
1228-
const viewer = yield* browser.attachViewer(viewerInput(opened.tabId, true));
1229-
yield* viewer.input({ type: "takeControl" });
1230-
const context = desktopConnections[0]!.context;
1260+
const { tabId, viewer, context, resize } = yield* openDesktopViewer;
12311261
yield* Effect.promise(() => desktopDetachReady.promise);
1232-
stallViewer(viewer, { _tag: "frame", data: Buffer.alloc(0), ack: Effect.void });
1233-
Object.assign(context.cssViewport, { width: 1000, height: 600 });
1234-
yield* Effect.promise(() => context.sessions[0]!.emitAsync("Page.frameResized"));
1262+
yield* viewer.input({ type: "takeControl" });
1263+
context.page.emit("filechooser", {
1264+
isMultiple: () => false,
1265+
element: () => ({ getAttribute: async () => ".csv" }),
1266+
setFiles: vi.fn(async () => {}),
1267+
});
1268+
let chooser = yield* Queue.take(viewer.output);
1269+
while (chooser._tag !== "fileChooser") chooser = yield* Queue.take(viewer.output);
1270+
yield* Queue.clear(viewer.output);
1271+
const control = expect.objectContaining({ _tag: "control", controller: "you" });
1272+
// A resize replaces a full backlog but keeps control and the controller's open picker.
1273+
yield* viewer.input({ type: "takeControl" });
1274+
let acked = stallViewer(viewer);
1275+
yield* resize(1000, 600);
12351276
expect(yield* Queue.takeAll(viewer.output)).toEqual([
12361277
{ _tag: "viewport", width: 1000, height: 600 },
1237-
expect.objectContaining({ _tag: "control", controller: "you" }),
1278+
control,
1279+
chooser,
1280+
]);
1281+
yield* acked;
1282+
// A control change keeps the newest size.
1283+
yield* resize(900, 500);
1284+
yield* resize(1200, 700);
1285+
acked = stallViewer(viewer);
1286+
yield* viewer.input({ type: "releaseControl" });
1287+
expect(yield* Queue.takeAll(viewer.output)).toEqual([
1288+
expect.objectContaining({ _tag: "control", controller: "unclaimed" }),
1289+
{ _tag: "viewport", width: 1200, height: 700 },
12381290
]);
1239-
stallViewer(viewer, { _tag: "frame", data: Buffer.alloc(0), ack: Effect.void });
1240-
desktopDetaches.emit("detach", { threadId: scope.thread.threadId, tabId: opened.tabId });
1291+
yield* acked;
1292+
// The desktop takes the page back; a resize after it cannot bury the reconnect.
1293+
acked = stallViewer(viewer);
1294+
desktopDetaches.emit("detach", { threadId: scope.thread.threadId, tabId });
12411295
yield* Effect.promise(() => desktopReleased.promise);
1296+
yield* resize(1000, 600);
12421297
expect(yield* Queue.takeAll(viewer.output)).toEqual([{ _tag: "reconnect" }]);
1298+
yield* acked;
12431299
}),
12441300
).pipe(Effect.provide(layer)),
12451301
);

‎apps/server/src/preview/ServerBrowser.ts‎

Lines changed: 28 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -102,8 +102,8 @@ const RECORDING_SCREENCAST = { format: "jpeg", quality: 90, everyNthFrame: 1 } a
102102
const decodeViewportSetting = Schema.decodeUnknownSync(PreviewViewportSettingSchema);
103103
const AGENT_CURSOR_MOVE_MS = 160;
104104
const AGENT_CURSOR_CLICK_LEAD_MS = 40;
105-
/** A dialog that opens mid-read blocks page script, so a desktop size read gives up after this. */
106-
const DESKTOP_VIEWPORT_READ_TIMEOUT_MS = 1_000;
105+
/** A dialog blocks page script, so a desktop size read gives up after this. */
106+
const DESKTOP_VIEWPORT_READ_TIMEOUT = "1 second";
107107

108108
const sleepUntil = (deadline: number) =>
109109
new Promise<void>((resolve) => setTimeout(resolve, Math.max(0, deadline - Date.now())));
@@ -311,12 +311,11 @@ interface ServerTab {
311311
setting: PreviewViewportSetting;
312312
colorScheme: PreviewAppearancePreference;
313313
zoomFactor: number;
314-
/** Last CSS size measured on the desktop, usable while a dialog blocks page script. */
314+
/** Last usable CSS size measured on the desktop. */
315315
desktopViewport: { readonly width: number; readonly height: number } | null;
316-
/** Numbers desktop size reads, so a slower older read cannot overwrite a newer one. */
317-
desktopViewportReads: number;
318-
/** The read that stored `desktopViewport`. */
319-
desktopViewportApplied: number;
316+
desktopViewportRead: Promise<ServerTab["desktopViewport"]>;
317+
/** A read queued behind `desktopViewportRead`, shared by every caller that waits for it. */
318+
desktopViewportNext: Promise<ServerTab["desktopViewport"]> | null;
320319
loading: boolean;
321320
closing: boolean;
322321
recording: Recording | null;
@@ -465,7 +464,6 @@ const make = Effect.gen(function* () {
465464
const previewBrowser = yield* PreviewBrowser.PreviewBrowser;
466465
const desktopChannel = yield* DesktopBrowserChannel.DesktopBrowserChannel;
467466
const agentTurns = yield* (yield* PreviewAgentActivity.PreviewAgentActivity).changes;
468-
const runSync = Effect.runSyncWith(yield* Effect.context<never>());
469467
const runFork = Effect.runForkWith(yield* Effect.context<never>());
470468
const runPromise = Effect.runPromiseWith(yield* Effect.context<never>());
471469
const launchServices = yield* Effect.context<ChildProcessSpawner.ChildProcessSpawner>();
@@ -559,8 +557,6 @@ const make = Effect.gen(function* () {
559557
if (tab.dialog === dialog) tab.dialog = null;
560558
ServerBrowserPage.invalidateRefs(tab.page);
561559
broadcastControl(tab);
562-
// The desktop page could not be measured while the dialog was open.
563-
if (tab.desktop) await broadcastViewport(tab).catch(constVoid);
564560
};
565561

566562
const report = (tab: ServerTab, navStatus: PreviewNavStatus) => {
@@ -618,9 +614,7 @@ const make = Effect.gen(function* () {
618614

619615
// Desktop pages have no Playwright viewport; an isolated world keeps page script
620616
// from overriding the CSS size, and failed reads preserve the last usable size.
621-
const measureDesktopViewport = async (tab: ServerTab) => {
622-
if (tab.dialog) return tab.desktopViewport;
623-
const read = ++tab.desktopViewportReads;
617+
const readDesktopViewport = async (tab: ServerTab) => {
624618
const readSize = async () => {
625619
const { frameTree } = await tab.cdp.send("Page.getFrameTree");
626620
const { executionContextId } = await tab.cdp.send("Page.createIsolatedWorld", {
@@ -634,24 +628,27 @@ const make = Effect.gen(function* () {
634628
});
635629
return asRecord(result.value);
636630
};
637-
let timer: ReturnType<typeof setTimeout> | undefined;
638-
const size = await Promise.race([
631+
const size = await runPromise(
639632
// A navigation can destroy the isolated world mid-read.
640-
readSize().catch(() => null),
641-
new Promise<null>((resolve) => {
642-
timer = setTimeout(() => resolve(null), DESKTOP_VIEWPORT_READ_TIMEOUT_MS);
643-
}),
644-
]);
645-
clearTimeout(timer);
646-
if (read < tab.desktopViewportApplied) return tab.desktopViewport;
647-
if (!size || typeof size.width !== "number" || typeof size.height !== "number")
648-
return tab.desktopViewport;
649-
if (size.width <= 0 || size.height <= 0) return tab.desktopViewport;
650-
tab.desktopViewportApplied = read;
651-
tab.desktopViewport = { width: size.width, height: size.height };
633+
Effect.promise(() => readSize().catch(() => null)).pipe(
634+
Effect.timeoutOption(DESKTOP_VIEWPORT_READ_TIMEOUT),
635+
Effect.map(Option.getOrNull),
636+
),
637+
);
638+
const width = size?.width;
639+
const height = size?.height;
640+
if (typeof width === "number" && width > 0 && typeof height === "number" && height > 0)
641+
tab.desktopViewport = { width, height };
652642
return tab.desktopViewport;
653643
};
654644

645+
// Reads run one at a time, and callers that arrive during a read share the next one.
646+
const measureDesktopViewport = (tab: ServerTab) =>
647+
(tab.desktopViewportNext ??= tab.desktopViewportRead.then(() => {
648+
tab.desktopViewportNext = null;
649+
return (tab.desktopViewportRead = readDesktopViewport(tab));
650+
}));
651+
655652
const layoutSize = async (tab: ServerTab) => {
656653
if (tab.desktop) return measureDesktopViewport(tab);
657654
const size = tab.page.viewportSize();
@@ -681,7 +678,7 @@ const make = Effect.gen(function* () {
681678

682679
const broadcastViewport = async (tab: ServerTab) => {
683680
const size = await layoutSize(tab);
684-
if (!size) return;
681+
if (!size || tab.closing) return;
685682
for (const viewer of tab.viewers) viewer.push({ _tag: "viewport", ...size });
686683
};
687684

@@ -838,8 +835,8 @@ const make = Effect.gen(function* () {
838835
colorScheme: "system",
839836
zoomFactor: 1,
840837
desktopViewport: null,
841-
desktopViewportReads: 0,
842-
desktopViewportApplied: 0,
838+
desktopViewportRead: Promise.resolve(null),
839+
desktopViewportNext: null,
843840
loading: false,
844841
closing: false,
845842
recording: null,
@@ -856,31 +853,8 @@ const make = Effect.gen(function* () {
856853
await applyRendering(tab, snapshot);
857854
if (desktop) {
858855
// The desktop resizes and zooms its webview itself; viewers map input with the new size.
859-
// Resizes arrive in bursts, so one read runs and at most one more follows it.
860-
let resizing: Promise<void> | null = null;
861-
let resizedAgain = false;
862856
cdp.on("Page.frameResized", () => {
863-
if (tab.viewers.size === 0) return;
864-
if (resizing) {
865-
resizedAgain = true;
866-
return resizing;
867-
}
868-
resizing = (async () => {
869-
do {
870-
resizedAgain = false;
871-
await broadcastViewport(tab).catch(constVoid);
872-
} while (resizedAgain);
873-
resizing = null;
874-
})();
875-
return resizing;
876-
});
877-
// Someone at the desktop can close a dialog in its own window, outside resolveDialog.
878-
cdp.on("Page.javascriptDialogClosed", () => {
879-
if (!tab.dialog) return;
880-
tab.dialog = null;
881-
ServerBrowserPage.invalidateRefs(page);
882-
broadcastControl(tab);
883-
if (tab.viewers.size > 0) void broadcastViewport(tab).catch(constVoid);
857+
if (tab.viewers.size > 0) return broadcastViewport(tab).catch(constVoid);
884858
});
885859
await cdp.send("Page.enable");
886860
}
@@ -2369,7 +2343,6 @@ const make = Effect.gen(function* () {
23692343
const recentFrames: Array<number> = [];
23702344
let screencastParams = Promise.resolve();
23712345
let screencastScale = 1;
2372-
let ended = false;
23732346
const startScreencast = (scale: number) => {
23742347
screencastScale = scale;
23752348
screencastParams = screencastParams.then(async () => {
@@ -2393,11 +2366,6 @@ const make = Effect.gen(function* () {
23932366
pressedButtons: new Map(),
23942367
push: (next) => {
23952368
// Dropped frames must still release Chromium.
2396-
if (ended) {
2397-
if (next._tag === "frame") runFork(next.ack);
2398-
return;
2399-
}
2400-
if (next._tag === "gone" || next._tag === "reconnect") ended = true;
24012369
if (Queue.offerUnsafe(output, next)) return;
24022370
if (next._tag === "frame") runFork(next.ack);
24032371
// State a stalled viewer cannot miss replaces its backlog. It runs
@@ -2416,15 +2384,6 @@ const make = Effect.gen(function* () {
24162384
const chooser =
24172385
next._tag === "control" || next._tag === "viewport" ? fileChooserMessage(tab) : null;
24182386
if (chooser && tab.control.controller === viewer.id) Queue.offerUnsafe(output, chooser);
2419-
// One-time notifications cannot be rebuilt from state; keep them in order.
2420-
// A former controller may still cache an older picker, so closes stay too.
2421-
// If they no longer all fit, the oldest go, so the latest clipboard survives.
2422-
const notifications = dropped.value.filter((item) =>
2423-
["fileChooserClosed", "popup", "download", "clipboard"].includes(item._tag),
2424-
);
2425-
const room = VIEWER_OUTPUT_LIMIT - runSync(Queue.size(output));
2426-
for (const item of notifications.slice(Math.max(0, notifications.length - room)))
2427-
Queue.offerUnsafe(output, item);
24282387
for (const item of dropped.value) if (item._tag === "frame") runFork(item.ack);
24292388
}
24302389
},

0 commit comments

Comments
 (0)