From 88926102b394469004c72dcf21066fbad626a829 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 17 Nov 2026 10:38:46 +0000 Subject: [PATCH] fix(server): preview_open reports a desktop tab it reveals as visible preview_open with open:true returned visible:false for a desktop tab that had been mounted hidden, even though the docked Browser panel showed it. The reply read the stale hidden report before the renderer's "shown" report came back. The desktop channel now has awaitShown, which subscribes to shown reports before checking the current state, like awaitAttached. An explicit reveal of a desktop tab that is not yet shown waits on it within the same REVEAL_VIEWER_WAIT_MS budget the streamed-viewer path uses, then returns status. Co-Authored-By: Claude Opus 5.5 --- .../src/preview/DesktopBrowserChannel.test.ts | 42 ++++++++++ .../src/preview/DesktopBrowserChannel.ts | 23 +++++- apps/server/src/preview/ServerBrowser.test.ts | 82 +++++++++++++++++++ apps/server/src/preview/ServerBrowser.ts | 9 +- 4 files changed, 152 insertions(+), 4 deletions(-) diff --git a/apps/server/src/preview/DesktopBrowserChannel.test.ts b/apps/server/src/preview/DesktopBrowserChannel.test.ts index 3cadfcb92e47a..b06def51be2cc 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"; @@ -66,6 +67,47 @@ it.effect("protects unknown desktop visibility until an explicit hidden report a ), ); +it.effect("awaitShown resolves once a hidden tab is reported shown", () => + Effect.gen(function* () { + const input = yield* Queue.unbounded(); + vi.mocked(NodeStream.fromReadable).mockReturnValue(Stream.fromQueue(input)); + const config = yield* ServerConfig.ServerConfig; + yield* Effect.gen(function* () { + const channel = yield* DesktopBrowserChannel.DesktopBrowserChannel; + const key = { threadId: "thread-1", tabId: "tab-1" }; + const send = (event: object) => + Queue.offer( + input, + new TextEncoder().encode(`${JSON.stringify(event)} +`), + ); + + expect(yield* channel.awaitShown(key, "5 seconds")).toBe(true); + yield* send({ type: "shown", ...key, shown: false }); + yield* send({ type: "attached", threadId: key.threadId, tabId: "sentinel" }); + yield* channel.awaitAttached({ threadId: key.threadId, tabId: "sentinel" }, "5 seconds"); + + const shown = yield* channel.awaitShown(key, "5 seconds").pipe(Effect.forkChild); + yield* send({ type: "shown", ...key, shown: true }); + expect(yield* Fiber.join(shown)).toBe(true); + }).pipe( + Effect.provide( + DesktopBrowserChannel.layer.pipe( + Layer.provide( + ServerConfig.layer({ ...config, desktopBrowserFd: 41, desktopBrowserControlFd: 42 }), + ), + ), + ), + ); + }).pipe( + Effect.provide( + ServerConfig.layerTest(process.cwd(), { prefix: "desktop-browser-channel-" }).pipe( + Layer.provide(NodeServices.layer), + ), + ), + ), +); + it.live("closes a tab's relay connection when the desktop detaches the tab", () => Effect.gen(function* () { const input = yield* Queue.unbounded(); diff --git a/apps/server/src/preview/DesktopBrowserChannel.ts b/apps/server/src/preview/DesktopBrowserChannel.ts index 5d6b55fa882e8..738d90dbcaf68 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 desktop reports the tab shown; subscribes before checking, like awaitAttached. */ + 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; @@ -64,6 +66,7 @@ const make = Effect.gen(function* () { const inputFd = config.desktopBrowserFd; const controlFd = config.desktopBrowserControlFd; const changes = yield* PubSub.unbounded<{ key: DesktopTabKey; attached: boolean }>(); + const shownChanges = yield* PubSub.unbounded<{ key: DesktopTabKey; shown: boolean }>(); const attachedTabs = new Set(); // Missing reports protect desktop tabs until the renderer explicitly marks them hidden. const shownTabs = new Map(); @@ -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 PubSub.publish(shownChanges, { key, shown: event.shown }); } }), Effect.catchCause((cause) => Effect.logWarning("desktop browser channel stopped", { cause })), @@ -253,6 +259,21 @@ const make = Effect.gen(function* () { return Effect.sync(() => attachedTabs.has(keyOf(key))); }), isShown: (key) => shownTabs.get(keyOf(key)) ?? true, + awaitShown: Effect.fn("DesktopBrowserChannel.awaitShown")(function (key, timeout) { + return Effect.scoped( + Effect.gen(function* () { + const subscription = yield* PubSub.subscribe(shownChanges); + if (shownTabs.get(keyOf(key)) ?? true) return true; + return yield* Stream.fromSubscription(subscription).pipe( + Stream.filter((change) => change.shown && keyOf(change.key) === 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 8087a25e6e559..7347898e93b8c 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -422,6 +422,12 @@ const desktopRenders = (tabId: string) => { let desktopAttachesLate = false; let desktopAttachWaiting = Promise.withResolvers(); const shownDesktopTabs = new Set(); +/** Marks a desktop tab shown the way the renderer's report does. */ +const showDesktopTab = (tabId: string) => { + shownDesktopTabs.add(tabId); + desktopDetaches.emit("shown", tabId); +}; +let desktopShowWaiting = Promise.withResolvers(); const releasedDesktopTabs: Array = []; const desktopLoadFailures = new Map(); const desktopTurns = new NodeEvents.EventEmitter(); @@ -509,6 +515,28 @@ const dependencies = Layer.mergeAll( ), isAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)), isShown: (key) => shownDesktopTabs.has(key.tabId), + awaitShown: (key, timeout) => + Effect.raceFirst( + Stream.callback((queue) => + Effect.acquireRelease( + Effect.sync(() => { + const onShown = (tabId: string) => Queue.offerUnsafe(queue, tabId); + desktopDetaches.on("shown", onShown); + if (shownDesktopTabs.has(key.tabId)) Queue.offerUnsafe(queue, key.tabId); + return onShown; + }), + (onShown) => Effect.sync(() => desktopDetaches.off("shown", onShown)), + ), + ).pipe( + Stream.filter((tabId) => tabId === key.tabId), + Stream.runHead, + Effect.as(true), + ), + Effect.sync(() => desktopShowWaiting.resolve()).pipe( + Effect.andThen(Effect.sleep(timeout)), + Effect.as(false), + ), + ), loadFailure: (key) => desktopLoadFailures.get(key.tabId), endpoint: (key) => Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () => @@ -592,6 +620,7 @@ beforeEach(() => { focusedFrame = null; desktopTabs.clear(); shownDesktopTabs.clear(); + desktopShowWaiting = Promise.withResolvers(); desktopLoadFailures.clear(); desktopRendersNext = false; desktopAttachesLate = false; @@ -3303,6 +3332,59 @@ 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 once the desktop shows it", + () => + Effect.scoped( + Effect.gen(function* () { + const broker = yield* Broker.PreviewAutomationBroker; + const manager = yield* Manager.PreviewManager; + const events = yield* manager.subscribeEvents; + yield* ServerBrowser.ServerBrowser; + yield* Effect.yieldNow; + // Like the renderer, the desktop reports the tab shown a round trip after the reveal. + yield* Effect.gen(function* () { + let event; + do event = yield* PubSub.take(events); + while (event.type !== "navigated" || !event.snapshot.revealRequest); + yield* Effect.promise(() => desktopShowWaiting.promise); + showDesktopTab(event.tabId); + }).pipe(Effect.forkScoped); + + desktopRendersNext = true; + const opened = yield* broker.invoke({ + scope, + operation: "open", + input: { reuseExistingTab: false, open: true }, + }); + + expect(opened.visible).toBe(true); + }), + ).pipe(Effect.provide(layer)), +); + +it.effect("preview_open stops waiting for a desktop tab that never shows", () => + Effect.scoped( + Effect.gen(function* () { + const broker = yield* Broker.PreviewAutomationBroker; + yield* ServerBrowser.ServerBrowser; + yield* Effect.yieldNow; + desktopRendersNext = true; + const opening = yield* broker + .invoke({ + scope, + operation: "open", + input: { reuseExistingTab: false, open: true }, + }) + .pipe(Effect.forkScoped); + yield* Effect.promise(() => desktopShowWaiting.promise); + yield* TestClock.adjust("1 second"); + + expect((yield* Fiber.join(opening)).visible).toBe(false); + }), + ).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* () { diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 59f70c887f146..e0506e895f133 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 tab mounted hidden keeps reporting hidden until its panel opens. + else if (reveal === true && tab.desktop !== null && !isVisible(tab)) + shown = runPromise(desktopChannel.awaitShown(tab, Math.max(0, waitMs))).then( + constVoid, ); } await shown;