From 451aa0edad2434bf1e6d138936299d329c064af3 Mon Sep 17 00:00:00 2001 From: Advait Paliwal Date: Tue, 17 Nov 2026 17:33:40 -0800 Subject: [PATCH 1/2] fix(desktop): hidden preview tabs free their memory after ten minutes A desktop preview tab that nobody can see now drops its webview after ten minutes and loads its page again when it is shown. A hidden tab whose page had already loaded waits until it is shown to load it again, so a remount no longer starts every hidden tab at once. Server tabs are left alone, since the agent drives them and the server browser already closes the idle ones. The desktop also clears a tab's sound indicator when its guest is destroyed, because Chromium sends no final audio-state change. Fixes #15579 Co-authored-by: Claude Opus 5.5 --- apps/desktop/src/preview/Manager.test.ts | 38 +++++++- apps/desktop/src/preview/Manager.ts | 19 +++- .../ElectronBrowserHost.browser.test.tsx | 90 ++++++++++++++++++- apps/web/src/browser/ElectronBrowserHost.tsx | 3 + apps/web/src/browser/HostedBrowserWebview.tsx | 30 ++++++- 5 files changed, 173 insertions(+), 7 deletions(-) diff --git a/apps/desktop/src/preview/Manager.test.ts b/apps/desktop/src/preview/Manager.test.ts index 2091ff3c7f8f2..12ea33cc6fb43 100644 --- a/apps/desktop/src/preview/Manager.test.ts +++ b/apps/desktop/src/preview/Manager.test.ts @@ -1714,19 +1714,25 @@ describe("PreviewManager", () => { let audible = false; let audibleAfterFirstRead = false; let audibleReads = 0; + let destroyed = false; return { setAudioMuted, emitAudioState: (next: boolean) => { audible = next; listeners.get("audio-state-changed")?.({ audible: next } as never); }, + /** Electron destroys a guest without a final audio-state change. */ + destroy: () => { + destroyed = true; + listeners.get("destroyed")?.(); + }, /** Simulate playback starting during attach before the tab owns the guest and can receive its events. */ startPlayingAfterFirstRead: () => { audibleAfterFirstRead = true; }, wc: { id, - isDestroyed: () => false, + isDestroyed: () => destroyed, isDevToolsOpened: () => false, getType: () => "webview", getURL: () => "https://example.com", @@ -1747,6 +1753,9 @@ describe("PreviewManager", () => { off: vi.fn((event: string) => { listeners.delete(event); }), + once: vi.fn((event: string, listener: (...args: never[]) => void) => { + listeners.set(event, listener); + }), ipc: { on: vi.fn(), off: vi.fn() }, send: webviewSend, navigationHistory: { canGoBack: () => false, canGoForward: () => false }, @@ -1816,6 +1825,33 @@ describe("PreviewManager", () => { ), ); + effectIt.effect("stops showing sound for a tab whose guest was destroyed", () => + withManager((manager) => + Effect.gen(function* () { + const guest = makeAudioWebContents(42); + fromId.mockReturnValue(guest.wc); + const states: PreviewManager.PreviewTabState[] = []; + + yield* manager.subscribeStateChanges((_tabId, state) => + Effect.sync(() => { + states.push(state); + }), + ); + yield* manager.prepareWebview(guest.wc); + yield* manager.createTab("tab_audio_destroyed"); + yield* manager.registerWebview("tab_audio_destroyed", 42); + guest.emitAudioState(true); + yield* Effect.yieldNow; + expect(states.at(-1)?.audible).toBe(true); + + guest.destroy(); + yield* Effect.yieldNow; + + expect(states.at(-1)).toMatchObject({ tabId: "tab_audio_destroyed", audible: false }); + }), + ), + ); + effectIt.effect("blocks late webview and capture starts during tab close", () => withManager((manager) => Effect.gen(function* () { diff --git a/apps/desktop/src/preview/Manager.ts b/apps/desktop/src/preview/Manager.ts index 32ac876996c81..ea24319a69506 100644 --- a/apps/desktop/src/preview/Manager.ts +++ b/apps/desktop/src/preview/Manager.ts @@ -2646,8 +2646,8 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function if (serverTab) browserHost.setCaptureDrawn(serverTab, drawn); }); - // A window reload or guest crash destroys the guest without the renderer reporting it hidden. - // The renderer reports again once a new guest registers. + // A window reload, guest crash or discarded hidden tab destroys the guest without the renderer + // reporting it hidden or Chromium reporting it silent. Both report again for the next guest. const hideDestroyedGuest = Effect.fnUntraced(function* (webContentsId: number) { for (const tab of (yield* SynchronizedRef.get(tabsRef)).values()) { if (tab.webContentsId === webContentsId && tab.serverTab) { @@ -2655,6 +2655,21 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function browserHost.setCaptureDrawn(tab.serverTab, false); } } + const updatedAt = yield* currentIso; + const silenced = yield* SynchronizedRef.modify(tabsRef, (tabs) => { + const tab = [...tabs.values()].find( + (candidate) => candidate.webContentsId === webContentsId && candidate.audible, + ); + if (!tab) return [Option.none(), tabs] as const; + const state: PreviewTabState = { ...tab, audible: false, updatedAt }; + return [ + Option.some(state), + replaceMap(tabs, (copy) => { + copy.set(tab.tabId, state); + }), + ] as const; + }); + if (Option.isSome(silenced)) yield* emitIfCurrent(silenced.value.tabId, silenced.value); }); const setAudioMuted = Effect.fn("PreviewManager.setAudioMuted")(function* ( diff --git a/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx b/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx index 29c217e064adc..e5ee0d08009f8 100644 --- a/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx +++ b/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx @@ -51,28 +51,55 @@ vi.mock(import("~/components/preview/usePreviewBridge"), async (original) => ({ usePreviewBridge: () => undefined, })); +// Stands in for a primary environment, whose server tabs the desktop renders natively. +vi.mock(import("./previewRuntime"), async (original) => ({ + ...(await original()), + rendersServerTabNatively: (_environmentId, _primaryEnvironmentId, snapshot) => + snapshot?.runtime === "server", +})); + import { __resetClientSettingsPersistenceForTests, ensureClientSettingsHydrated, } from "~/hooks/useSettings"; import { reconcilePreviewServerSessions, resetPreviewStateForTests } from "~/previewStateStore"; import { AppAtomRegistryProvider } from "~/rpc/atomRegistry"; +import { acquireBrowserSurface, useBrowserSurfaceStore } from "./browserSurfaceStore"; import { ElectronBrowserHost } from "./ElectronBrowserHost"; +import { previewRuntimeTabId } from "./previewRuntimeTabId"; const threadRef = scopeThreadRef( EnvironmentId.make("host-webview-order"), ThreadId.make("thread-webview-order"), ); -const snapshot = (tabId: string, updatedAt: string): PreviewSessionSnapshot => ({ +const snapshot = ( + tabId: string, + updatedAt: string, + overrides: Partial = {}, +): PreviewSessionSnapshot => ({ threadId: threadRef.threadId, tabId, - navStatus: { _tag: "Success", url: `https://example.com/${tabId}`, title: tabId }, + navStatus: { _tag: "Loading", url: `https://example.com/${tabId}`, title: tabId }, canGoBack: false, canGoForward: false, updatedAt, + ...overrides, +}); + +const loaded = (url: string) => ({ + navStatus: { _tag: "Success" as const, url, title: url }, }); +const PANEL_RECT = { x: 0, y: 0, width: 800, height: 600 }; + +/** Shows the tab in a visible preview panel; setup() clears it. */ +function showTab(tabId: string) { + const surface = acquireBrowserSurface(previewRuntimeTabId(threadRef, "server-a", tabId)); + surface.present(PANEL_RECT, true); + return surface; +} + function setup(): Disposable { __resetClientSettingsPersistenceForTests(); mocks.getClientSettings.mockReset().mockResolvedValue(DEFAULT_CLIENT_SETTINGS); @@ -88,6 +115,7 @@ function setup(): Disposable { return { [Symbol.dispose]() { resetPreviewStateForTests(); + useBrowserSurfaceStore.setState({ byTabId: {}, activityByTabId: {} }); __resetClientSettingsPersistenceForTests(); }, }; @@ -160,4 +188,62 @@ describe("ElectronBrowserHost", () => { expect(after).toHaveLength(2); expect(after.every((node, index) => node.isSameNode(before[index]!))).toBe(true); }); + + it("drops a hidden desktop tab's guest after ten minutes and reloads its page when shown", async () => { + using _state = setup(); + reconcilePreviewServerSessions(threadRef, { + sessions: [ + snapshot("tab_desktop", "2026-01-01T00:00:01.000Z"), + snapshot("tab_agent_1", "2026-01-01T00:00:02.000Z", { runtime: "server" }), + ], + serverEpoch: "server-a", + revision: 1, + }); + await using screen = await renderHost(); + const guestOf = (tabId: string) => + screen.container.querySelector(`webview[data-preview-server-tab="${tabId}"]`); + const panel = await act(() => showTab("tab_desktop")); + using _timers = fakeTimers(); + await act(() => panel.present(PANEL_RECT, false)); + const firstGuest = guestOf("tab_desktop"); + expect(firstGuest).not.toBeNull(); + + await act(() => vi.advanceTimersByTimeAsync(10 * 60_000 - 1)); + expect(guestOf("tab_desktop")).toBe(firstGuest); + await act(() => vi.advanceTimersByTimeAsync(1)); + expect(guestOf("tab_desktop")).toBeNull(); + // The agent's server tab is the server browser's to close. + expect(guestOf("tab_agent_1")).not.toBeNull(); + + await act(() => { + reconcilePreviewServerSessions(threadRef, { + sessions: [ + snapshot("tab_desktop", "2026-01-01T00:00:03.000Z", loaded("https://example.com/next")), + snapshot("tab_agent_1", "2026-01-01T00:00:02.000Z", { runtime: "server" }), + ], + serverEpoch: "server-a", + revision: 2, + }); + panel.present(PANEL_RECT, true); + }); + expect(guestOf("tab_desktop")?.getAttribute("src")).toBe("https://example.com/next"); + }); + + it("waits until a hidden tab whose page already loaded is shown to load it", async () => { + using _state = setup(); + reconcilePreviewServerSessions(threadRef, { + sessions: [ + snapshot("tab_loaded", "2026-01-01T00:00:01.000Z", loaded("https://example.com/loaded")), + ], + serverEpoch: "server-a", + revision: 1, + }); + await using screen = await renderHost(); + const guest = () => + screen.container.querySelector('webview[data-preview-server-tab="tab_loaded"]'); + expect(guest()).toBeNull(); + + await act(() => showTab("tab_loaded")); + expect(guest()?.getAttribute("src")).toBe("https://example.com/loaded"); + }); }); diff --git a/apps/web/src/browser/ElectronBrowserHost.tsx b/apps/web/src/browser/ElectronBrowserHost.tsx index d71b7a2b6b2ba..2aa3583c05083 100644 --- a/apps/web/src/browser/ElectronBrowserHost.tsx +++ b/apps/web/src/browser/ElectronBrowserHost.tsx @@ -143,6 +143,9 @@ export function ElectronBrowserHost() { tabId={snapshot.tabId} runtimeTabId={runtimeTabId} initialUrl={url} + initialUrlLoaded={ + snapshot.navStatus._tag === "Success" || snapshot.navStatus._tag === "LoadFailed" + } viewport={snapshot.viewport ?? FILL_PREVIEW_VIEWPORT} pictureInPicture={pictureInPicture} profileId={snapshot.profileId} diff --git a/apps/web/src/browser/HostedBrowserWebview.tsx b/apps/web/src/browser/HostedBrowserWebview.tsx index 023fb03c3aa17..5f60833586e17 100644 --- a/apps/web/src/browser/HostedBrowserWebview.tsx +++ b/apps/web/src/browser/HostedBrowserWebview.tsx @@ -36,6 +36,9 @@ import { type WebviewCrashRecoveryState, } from "./webviewCrashRecovery"; +// Showing a discarded tab reloads its page, so it trades in-page state for the guest's memory. +const HIDDEN_GUEST_DISCARD_MS = 10 * 60_000; + interface ElectronWebview extends HTMLElement { src: string; partition: string; @@ -56,6 +59,8 @@ export function HostedBrowserWebview(props: { readonly tabId: string; readonly runtimeTabId: string; readonly initialUrl: string | null; + /** An earlier guest finished loading `initialUrl`, so a hidden tab can wait to load it again. */ + readonly initialUrlLoaded: boolean; readonly viewport: PreviewViewportSetting; readonly pictureInPicture: boolean; /** Fixed for the tab lifetime; Electron reads partition before guest attachment. */ @@ -72,6 +77,7 @@ export function HostedBrowserWebview(props: { tabId, runtimeTabId, initialUrl, + initialUrlLoaded, viewport, pictureInPicture, zoomFactor, @@ -142,12 +148,33 @@ export function HostedBrowserWebview(props: { const [recoverySrc, setRecoverySrc] = useState(initialSrc); const active = presentation.visible && presentation.rect !== null; const shown = active || pictureInPicture; + const renderingActive = active || backgroundActivity || pictureInPicture || recordingActive; + // Server tabs are the agent's, and the server browser already closes the idle ones. + const discardable = !serverDriven && !renderingActive; + const [guestDiscarded, setGuestDiscarded] = useState( + () => discardable && initialUrl !== null && initialUrlLoaded, + ); + if (guestDiscarded && !discardable) { + setGuestDiscarded(false); + setRecoverySrc(initialUrl ?? initialSrc); + setWebviewGeneration((generation) => generation + 1); + } const reportedShown = useEffectEvent(() => serverDriven && shown); const remountCrashedWebview = useEffectEvent(() => { setRecoverySrc(initialUrl ?? initialSrc); setWebviewGeneration((generation) => generation + 1); }); + // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- drops the guest's renderer once the tab has stayed hidden for the idle window + useEffect(() => { + if (!discardable || guestDiscarded) return; + const timeout = window.setTimeout(() => { + setGuestDiscarded(true); + setWebviewGeneration((generation) => generation + 1); + }, HIDDEN_GUEST_DISCARD_MS); + return () => window.clearTimeout(timeout); + }, [discardable, guestDiscarded]); + const setWebviewRef = (node: HTMLElement | null) => { webviewRef.current = node as ElectronWebview | null; }; @@ -331,7 +358,7 @@ export function HostedBrowserWebview(props: { }; }, [clientSettingsHydrated, fullDetail, runtimeTabId, serverDriven]); - if (!clientSettingsHydrated || !config) return null; + if (!clientSettingsHydrated || !config || guestDiscarded) return null; // This fixed wrapper sits outside the right panel shell, so it takes thumb presses itself. const navigateThumb = (direction: "back" | "forward") => { @@ -339,7 +366,6 @@ export function HostedBrowserWebview(props: { else void previewBridge?.goForward(runtimeTabId); }; - const renderingActive = active || backgroundActivity || pictureInPicture || recordingActive; const viewportTransform = resolveBrowserViewportTransform(layout.viewportScale, fullDetail); const wrapperStyle = resolveHostedBrowserWebviewWrapperStyle({ active, From 5a71afe2abc9d0ab850759b12c268c43cf20ca13 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 18 Nov 2026 02:05:32 +0000 Subject: [PATCH 2/2] fix(server): hidden agent tabs the desktop draws close after the idle window The server's idle sweep skipped desktop-hosted agent tabs, so below the 32-tab limit their webviews stayed alive forever. The sweep now closes them too, counting a tab as used while it is on screen so its idle window starts when it was hidden. The open-time slot reclaim this made redundant is gone. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/preview/ServerBrowser.test.ts | 130 ++++-------------- apps/server/src/preview/ServerBrowser.ts | 66 ++------- 2 files changed, 42 insertions(+), 154 deletions(-) diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index 46a28b26aa8b9..584befedf5c30 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -3848,7 +3848,7 @@ it.effect("failed session and browser launches release capacity, as does closing ).pipe(Effect.provide(layer)), ); -it.effect("a full server takes back the slot of the longest idle agent tab nobody views", () => +it.effect("agent tabs the desktop renders close once hidden and idle, without another open", () => Effect.scoped( Effect.gen(function* () { const broker = yield* Broker.PreviewAutomationBroker; @@ -3857,116 +3857,40 @@ it.effect("a full server takes back the slot of the longest idle agent tab nobod yield* Effect.yieldNow; const now = vi.spyOn(Date, "now").mockReturnValue(0); yield* Effect.addFinalizer(() => Effect.sync(() => now.mockRestore())); - const open = (providerSessionId: string) => { + const opened: Array = []; + for (let index = 0; index < 3; index++) { desktopRendersNext = true; - return broker.invoke({ - scope: asSession(providerSessionId), + const status = yield* broker.invoke({ + scope: asSession(`agent-${index}`), operation: "open", input: { reuseExistingTab: false, open: false }, }); - }; - const opened: Array = []; - for (let index = 0; index < 32; index++) { - now.mockReturnValue(index); - opened.push((yield* open(`agent-${Math.floor(index / 8)}`)).tabId!); + opened.push(status.tabId!); } + shownDesktopTabs.add(opened[1]!); + const openTabIds = () => + manager + .list({ threadId: scope.thread.threadId }) + .pipe(Effect.map(({ sessions }) => sessions.map((session) => session.tabId).toSorted())); + const sweepAt = (minutes: number) => { + now.mockReturnValue(minutes * 60 * 1000); + return TestClock.adjust("1 minute"); + }; - now.mockReturnValue(100); - yield* broker.invoke({ - scope: asSession("agent-observer"), - operation: "status", - tabId: PreviewTabId.make(opened[0]!), - input: {}, - }); + yield* sweepAt(29); + expect(yield* openTabIds()).toEqual(opened.toSorted()); - // Inside the idle window every desktop tab keeps its slot. - now.mockReturnValue(29 * 60 * 1000); - expect(yield* open("agent-new").pipe(Effect.flip)).toMatchObject({ reason: "tabLimit" }); - expect(releasedDesktopTabs).toEqual([]); - - now.mockReturnValue(31 * 60 * 1000); - // A session at its own limit couldn't use a freed slot, so nothing closes for it. - expect(yield* open("agent-3").pipe(Effect.flip)).toMatchObject({ reason: "tabLimit" }); - expect(releasedDesktopTabs).toEqual([]); - // Tabs a desktop window shows keep their slots however long they sit idle. - for (const tabId of opened) shownDesktopTabs.add(tabId); - expect(yield* open("agent-new").pipe(Effect.flip)).toMatchObject({ reason: "tabLimit" }); - expect(releasedDesktopTabs).toEqual([]); - shownDesktopTabs.clear(); - shownDesktopTabs.add(opened[1]!); - desktopConnections[2]!.context.page.beforeUnload = "listen"; - const events = yield* manager.subscribeEvents; - const releases = yield* Queue.unbounded(); - const recordRelease = (tabId: string) => Queue.offerUnsafe(releases, tabId); - desktopDetaches.on("release", recordRelease); - yield* Effect.addFinalizer(() => - Effect.sync(() => desktopDetaches.off("release", recordRelease)), - ); - const fresh = yield* open("agent-new"); - expect(fresh.tabId).toBeDefined(); - expect(yield* Queue.take(releases)).toBe(opened[2]); - expect(desktopConnections[2]!.context.page.unloadEvents).toEqual([ - "beforeunload", - "pagehide", - "visibilitychange", - ]); - yield* Stream.fromSubscription(events).pipe( - Stream.filter((event) => event.type === "closed" && event.tabId === opened[2]), - Stream.runHead, - ); - expect(releasedDesktopTabs).toEqual([opened[2]]); - const { sessions } = yield* manager.list({ threadId: scope.thread.threadId }); - expect(sessions.map((session) => session.tabId).toSorted()).toEqual( - [...opened.filter((tabId) => tabId !== opened[2]), fresh.tabId!].toSorted(), - ); + yield* sweepAt(31); + expect(releasedDesktopTabs.toSorted()).toEqual([opened[0], opened[2]].toSorted()); + // A shown tab keeps its guest however long the agent leaves it alone. + expect(yield* openTabIds()).toEqual([opened[1]]); - // A second open must reclaim a different tab while the first page is unloading. - const closingPage = desktopConnections[3]!.context.page; - closingPage.beforeUnload = "listen"; - closingPage.unloadGate = Promise.withResolvers(); - const closeRequests = yield* Queue.unbounded(); - const close = manager.close; - const closeSpy = vi - .spyOn(manager, "close") - .mockImplementation((input) => - Queue.offer(closeRequests, undefined).pipe(Effect.andThen(close(input))), - ); - yield* Effect.addFinalizer(() => Effect.sync(() => closeSpy.mockRestore())); - const firstOpen = yield* open("agent-concurrent").pipe(Effect.forkScoped); - yield* Queue.take(closeRequests); - yield* Effect.promise(() => closingPage.pagehideWatched.promise); - const secondOpen = yield* open("agent-concurrent").pipe(Effect.forkScoped); - yield* Queue.take(closeRequests); - closingPage.unloadGate.resolve(); - const concurrent = yield* Effect.all([Fiber.join(firstOpen), Fiber.join(secondOpen)]); - expect(concurrent.every((status) => status.available)).toBe(true); - const remaining = (yield* manager.list({ threadId: scope.thread.threadId })).sessions; - expect(remaining).toHaveLength(32); - const closedBeforeReturn = yield* Deferred.make(); - const finishClose = yield* Deferred.make(); - let heldClose = false; - closeSpy.mockImplementation((input) => { - const hold = !heldClose; - heldClose = true; - return close(input).pipe( - Effect.andThen( - hold - ? Deferred.succeed(closedBeforeReturn, undefined).pipe( - Effect.andThen(Deferred.await(finishClose)), - ) - : Effect.void, - ), - ); - }); - const reclaimingOpen = yield* open("agent-reclaiming").pipe(Effect.forkScoped); - yield* Deferred.await(closedBeforeReturn); - const takingFreedSlot = yield* open("agent-taking-free-slot"); - expect(takingFreedSlot.available).toBe(true); - yield* Deferred.succeed(finishClose, undefined); - expect((yield* Fiber.join(reclaimingOpen)).available).toBe(true); - expect((yield* manager.list({ threadId: scope.thread.threadId })).sessions).toHaveLength(32); - expect(remaining.some((session) => session.tabId === opened[3])).toBe(false); - expect(remaining.some((session) => session.tabId === opened[4])).toBe(false); + // Its idle window starts when it was last on screen, not when the agent last used it. + shownDesktopTabs.delete(opened[1]!); + yield* sweepAt(60); + expect(yield* openTabIds()).toEqual([opened[1]]); + yield* sweepAt(62); + expect(yield* openTabIds()).toEqual([]); }), ).pipe(Effect.provide(layer)), ); diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 8d4e6080daa49..ec76146cd29c0 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -1783,58 +1783,23 @@ const make = Effect.gen(function* () { const isVisible = (tab: ServerTab) => tab.viewers.size > 0 || (tab.desktop !== null && desktopChannel.isShown(tab)); - const reclaimingTabs = new Set(); const idleAgentTabs = () => { const cutoff = Date.now() - AGENT_TAB_IDLE_MS; return [...tabs.values()].filter( - (tab) => - tab.control.agentId !== null && - !reclaimingTabs.has(tab) && - !isVisible(tab) && - tab.usedAt < cutoff, + (tab) => tab.control.agentId !== null && !isVisible(tab) && tab.usedAt < cutoff, ); }; - // The desktop app renders every server tab, so idle desktop agent tabs would otherwise - // hold the server's budget forever. Hidden ones give up their slots, longest idle first, - // only when an agent needs one and has room for it. - const freeIdleAgentSlot = async (agentSessionId: string) => { - if (!serverAtTabLimit() || agentAtTabLimit(agentSessionId)) return; - const longestIdle = idleAgentTabs().sort((left, right) => left.usedAt - right.usedAt)[0]; - if (longestIdle) { - reclaimingTabs.add(longestIdle); - try { - await runPromise( - manager.close({ threadId: longestIdle.threadId, tabId: longestIdle.tabId }), - ); - dropTab(longestIdle, false); - } finally { - reclaimingTabs.delete(longestIdle); - } - } - }; - // A Playwright launch must settle before its capacity can be released. const openTab = Effect.fn("ServerBrowser.openTab")(function* ( input: Parameters[0], - options: { readonly reclaimIdleSlot?: boolean } = {}, ) { let key: string = NodeCrypto.randomUUID(); const reservation = { agentId: input.automationOwner ?? null }; return yield* Effect.acquireUseRelease( Effect.tryPromise({ try: async () => { - if (input.automationOwner !== undefined) { - while ( - options.reclaimIdleSlot && - serverAtTabLimit() && - !agentAtTabLimit(input.automationOwner) && - idleAgentTabs().length > 0 - ) { - await freeIdleAgentSlot(input.automationOwner); - } - assertTabCapacity(input.automationOwner); - } + if (input.automationOwner !== undefined) assertTabCapacity(input.automationOwner); pendingTabs.set(key, reservation); }, catch: ServerBrowserPage.toOperationError, @@ -1871,10 +1836,12 @@ const make = Effect.gen(function* () { ); }, Effect.uninterruptible); - // Desktop browsing bypasses streamed viewers and server input tracking, - // so these idle signals only apply to headless tabs. + // Desktop browsing bypasses server input tracking, so a shown tab counts as used; the idle + // window then starts when it was last on screen, and hidden desktop guests do not live forever. const closeIdleAgentTabs = () => { - for (const tab of idleAgentTabs()) if (tab.desktop === null) dropTab(tab, true); + const now = Date.now(); + for (const tab of tabs.values()) if (isVisible(tab)) tab.usedAt = now; + for (const tab of idleAgentTabs()) dropTab(tab, true); }; const latestThreadTab = (threadId: string, agentSessionId?: string) => { @@ -2590,17 +2557,14 @@ const make = Effect.gen(function* () { const tab = existing ?? (await runPromise( - openTab( - { - threadId: request.threadId, - ...(url ? { url } : {}), - ...(profileId === undefined ? {} : { profileId }), - runtime: "server", - reveal: false, - automationOwner: request.agentSessionId, - }, - { reclaimIdleSlot: true }, - ), + openTab({ + threadId: request.threadId, + ...(url ? { url } : {}), + ...(profileId === undefined ? {} : { profileId }), + runtime: "server", + reveal: false, + automationOwner: request.agentSessionId, + }), )); if (existing?.dialog) throw new BrowserControlInterrupted({