From 030d8d55edb11c7c8791109fd8ca51506a6c4f36 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 17 Nov 2026 10:07:11 +0000 Subject: [PATCH 1/3] test(server): preview_open reports a hidden desktop tab it reveals as visible Reproduces #38052: preview_open({tabId, open: true}) on a desktop tab the renderer had reported hidden returns visible: false, because the server reads the tab's shown state before the docked panel's report arrives. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/preview/ServerBrowser.test.ts | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index 8087a25e6e559..e07ac23664d60 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -3303,6 +3303,45 @@ it.effect("preview_open reports a tab it shows as visible once the client attach ).pipe(Effect.provide(layer)), ); +it.effect("preview_open reports a hidden desktop tab it reveals as visible", () => + Effect.scoped( + Effect.gen(function* () { + const broker = yield* Broker.PreviewAutomationBroker; + const manager = yield* Manager.PreviewManager; + yield* ServerBrowser.ServerBrowser; + const events = yield* manager.subscribeEvents; + yield* Effect.yieldNow; + desktopRendersNext = true; + const created = yield* broker.invoke({ + scope, + operation: "open", + input: { reuseExistingTab: false, open: false }, + }); + const tabId = PreviewTabId.make(created.tabId!); + expect(created.visible).toBe(false); + // Like the desktop renderer, the docked panel reports the tab shown after the reveal arrives. + yield* Effect.gen(function* () { + let event; + do event = yield* PubSub.take(events); + while (event.type !== "navigated" || !event.snapshot.revealRequest); + // The report crosses the client, the desktop main process and its pipe, so it lands a task later. + yield* Effect.yieldNow; + yield* Effect.sync(() => shownDesktopTabs.add(tabId)); + }).pipe(Effect.forkScoped); + + const opened = yield* broker.invoke({ + scope, + tabId, + operation: "open", + input: { open: true }, + }); + + expect(opened.visible).toBe(true); + expect(opened.tabs).toEqual([expect.objectContaining({ tabId, visible: true })]); + }), + ).pipe(Effect.provide(layer)), +); + it.effect("a session's own tab stays its default while other sessions' tabs are listed", () => Effect.scoped( Effect.gen(function* () { From d3c22606ac1f6aba7ca6b00cc499928585fe00e7 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 17 Nov 2026 10:17:59 +0000 Subject: [PATCH 2/3] fix(server): preview_open reports a desktop tab it reveals as visible preview_open read a desktop tab's shown state right after requesting the reveal, before the docked panel's shown report reached the server, so a tab the renderer had reported hidden came back visible: false. On an explicit show of a desktop tab that is not yet shown, wait (bounded like the viewer wait) for the desktop channel's shown report. Co-Authored-By: Claude Opus 5.5 --- .../src/preview/DesktopBrowserChannel.test.ts | 5 ++-- .../src/preview/DesktopBrowserChannel.ts | 27 +++++++++++++++++-- apps/server/src/preview/ServerBrowser.test.ts | 18 ++++++++++++- apps/server/src/preview/ServerBrowser.ts | 9 ++++--- 4 files changed, 51 insertions(+), 8 deletions(-) diff --git a/apps/server/src/preview/DesktopBrowserChannel.test.ts b/apps/server/src/preview/DesktopBrowserChannel.test.ts index 3cadfcb92e47a..bf5cbc2d3c3ff 100644 --- a/apps/server/src/preview/DesktopBrowserChannel.test.ts +++ b/apps/server/src/preview/DesktopBrowserChannel.test.ts @@ -2,6 +2,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; import * as NodeStream from "@effect/platform-node/NodeStream"; import { expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; import * as Queue from "effect/Queue"; import * as Stream from "effect/Stream"; @@ -38,9 +39,9 @@ it.effect("protects unknown desktop visibility until an explicit hidden report a yield* channel.awaitAttached({ threadId: key.threadId, tabId: "sentinel-1" }, "5 seconds"); expect(channel.isShown(key)).toBe(false); + const shown = yield* channel.awaitShown(key, "5 seconds").pipe(Effect.forkChild); yield* send({ type: "shown", ...key, shown: true }); - yield* send({ type: "attached", threadId: key.threadId, tabId: "sentinel-2" }); - yield* channel.awaitAttached({ threadId: key.threadId, tabId: "sentinel-2" }, "5 seconds"); + expect(yield* Fiber.join(shown)).toBe(true); expect(channel.isShown(key)).toBe(true); yield* send({ type: "shown", ...key, shown: false }); diff --git a/apps/server/src/preview/DesktopBrowserChannel.ts b/apps/server/src/preview/DesktopBrowserChannel.ts index 5d6b55fa882e8..4da0efe3ce8f0 100644 --- a/apps/server/src/preview/DesktopBrowserChannel.ts +++ b/apps/server/src/preview/DesktopBrowserChannel.ts @@ -47,6 +47,8 @@ export class DesktopBrowserChannel extends Context.Service< readonly isAttached: (key: DesktopTabKey) => Effect.Effect; /** Whether a desktop window draws the tab on screen, which no streamed viewer counts. */ readonly isShown: (key: DesktopTabKey) => boolean; + /** Resolves true once the tab is shown, or false on timeout. */ + readonly awaitShown: (key: DesktopTabKey, timeout: Duration.Input) => Effect.Effect; /** A load failure the desktop saw, possibly before the server connected to the tab. */ readonly loadFailure: (key: DesktopTabKey) => PreviewAutomationLoadError | undefined; readonly endpoint: (key: DesktopTabKey) => Effect.Effect; @@ -67,6 +69,7 @@ const make = Effect.gen(function* () { const attachedTabs = new Set(); // Missing reports protect desktop tabs until the renderer explicitly marks them hidden. const shownTabs = new Map(); + const shownReports = yield* PubSub.unbounded(); const loadFailures = new Map(); const inbound = new Map>(); const writeLock = yield* Semaphore.make(1); @@ -92,6 +95,9 @@ const make = Effect.gen(function* () { return Effect.void; }), isShown: () => false, + awaitShown: Effect.fn("DesktopBrowserChannel.awaitShown")(function () { + return Effect.succeed(false); + }), loadFailure: () => undefined, }); } @@ -149,7 +155,7 @@ const make = Effect.gen(function* () { } case "shown": shownTabs.set(id, event.shown); - return Effect.void; + return event.shown ? PubSub.publish(shownReports, id) : Effect.void; } }), Effect.catchCause((cause) => Effect.logWarning("desktop browser channel stopped", { cause })), @@ -224,6 +230,8 @@ const make = Effect.gen(function* () { return `ws://127.0.0.1:${address.port}/${secret}`; }); + const isShown = (key: DesktopTabKey) => shownTabs.get(keyOf(key)) ?? true; + return DesktopBrowserChannel.of({ available: true, awaitAttached: Effect.fn("DesktopBrowserChannel.awaitAttached")(function (key, timeout) { @@ -252,7 +260,22 @@ const make = Effect.gen(function* () { isAttached: Effect.fn("DesktopBrowserChannel.isAttached")(function (key) { return Effect.sync(() => attachedTabs.has(keyOf(key))); }), - isShown: (key) => shownTabs.get(keyOf(key)) ?? true, + isShown, + awaitShown: Effect.fn("DesktopBrowserChannel.awaitShown")(function (key, timeout) { + return Effect.scoped( + Effect.gen(function* () { + const subscription = yield* PubSub.subscribe(shownReports); + if (isShown(key)) return true; + return yield* Stream.fromSubscription(subscription).pipe( + Stream.filter((id) => id === keyOf(key)), + Stream.runHead, + Effect.map(Option.isSome), + Effect.timeoutOption(timeout), + Effect.map((result) => Option.getOrElse(result, () => false)), + ); + }), + ); + }), loadFailure: (key) => loadFailures.get(keyOf(key)), endpoint, turn: Effect.fn("DesktopBrowserChannel.turn")(function (threadId, active) { diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index e07ac23664d60..46a28b26aa8b9 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -421,7 +421,13 @@ const desktopRenders = (tabId: string) => { /** When set, a desktop that has not attached a tab waits for it the way the real channel does. */ let desktopAttachesLate = false; let desktopAttachWaiting = Promise.withResolvers(); -const shownDesktopTabs = new Set(); +const shownDesktopTabs = new (class extends Set { + override add(tabId: string) { + super.add(tabId); + desktopDetaches.emit("shown", tabId); + return this; + } +})(); const releasedDesktopTabs: Array = []; const desktopLoadFailures = new Map(); const desktopTurns = new NodeEvents.EventEmitter(); @@ -509,6 +515,16 @@ const dependencies = Layer.mergeAll( ), isAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)), isShown: (key) => shownDesktopTabs.has(key.tabId), + awaitShown: (key, timeout) => + shownDesktopTabs.has(key.tabId) + ? Effect.succeed(true) + : Effect.callback((resume) => { + const onShown = (tabId: string) => { + if (tabId === key.tabId) resume(Effect.succeed(true)); + }; + desktopDetaches.on("shown", onShown); + return Effect.sync(() => desktopDetaches.off("shown", onShown)); + }).pipe(Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.succeed(false) })), loadFailure: (key) => desktopLoadFailures.get(key.tabId), endpoint: (key) => Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () => diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 59f70c887f146..43b7509ca89f0 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -2649,10 +2649,13 @@ const make = Effect.gen(function* () { }), ); // Only an explicit show is sure to reach a client; desktop tabs are visible without a viewer. + const waitMs = Math.min(REVEAL_VIEWER_WAIT_MS, deadlineMs - performance.now()); if (reveal === true && tab.viewers.size === 0 && tab.desktop === null) - shown = awaitViewer( - tab, - Math.min(REVEAL_VIEWER_WAIT_MS, deadlineMs - performance.now()), + shown = awaitViewer(tab, waitMs); + // A desktop panel reports the revealed tab shown a few hops after the reveal. + else if (reveal === true && !isVisible(tab)) + shown = runPromise(desktopChannel.awaitShown(tab, Math.max(0, waitMs))).then( + constVoid, ); } await shown; From 31870232edb29d01748b2458f1ae71fed0b72948 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 17 Nov 2026 11:09:44 +0000 Subject: [PATCH 3/3] fix(server): give a desktop panel longer to report a revealed tab shown On a busy machine the docked panel's shown report reached the server just past the one-second cap the reveal wait shared with streamed viewers, so preview_open still returned visible: false. Desktop tabs now wait up to three seconds, still bounded by the request deadline. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/preview/ServerBrowser.ts | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 43b7509ca89f0..8d4e6080daa49 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -128,6 +128,8 @@ const DESKTOP_VIEWPORT_READ_TIMEOUT = "1 second"; const DESKTOP_RESIZE_WAIT_MS = 1000; // A revealed tab's client opens the panel and attaches its stream a few round trips later, remote ones included. const REVEAL_VIEWER_WAIT_MS = 1000; +// A desktop panel's shown report waits on the renderer's layout, which a busy machine can push past a second. +const REVEAL_DESKTOP_SHOWN_WAIT_MS = 3000; const sleepUntil = (deadline: number) => new Promise((resolve) => setTimeout(resolve, Math.max(0, deadline - Date.now()))); @@ -2649,14 +2651,17 @@ const make = Effect.gen(function* () { }), ); // Only an explicit show is sure to reach a client; desktop tabs are visible without a viewer. - const waitMs = Math.min(REVEAL_VIEWER_WAIT_MS, deadlineMs - performance.now()); + const remainingMs = deadlineMs - performance.now(); if (reveal === true && tab.viewers.size === 0 && tab.desktop === null) - shown = awaitViewer(tab, waitMs); + shown = awaitViewer(tab, Math.min(REVEAL_VIEWER_WAIT_MS, remainingMs)); // A desktop panel reports the revealed tab shown a few hops after the reveal. else if (reveal === true && !isVisible(tab)) - shown = runPromise(desktopChannel.awaitShown(tab, Math.max(0, waitMs))).then( - constVoid, - ); + shown = runPromise( + desktopChannel.awaitShown( + tab, + Math.max(0, Math.min(REVEAL_DESKTOP_SHOWN_WAIT_MS, remainingMs)), + ), + ).then(constVoid); } await shown; return statusWithTitle(tab, request.agentSessionId);