diff --git a/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts b/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts index 5870a9ccb9b..7d894746866 100644 --- a/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts +++ b/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts @@ -1,3 +1,4 @@ +import { consumeReopenAfterSleep } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react' import { useAppStore } from '@/store' import { runtimeEnvironmentIdOrLocalUnlessTwin } from '@/lib/workspace/ownership/worktree-runtime-owner' @@ -147,6 +148,17 @@ export function useRemoteBrowserPageLifecycle({ state.removeRemoteBrowserPageHandle(browserTab.id, remotePageId) } lifecycle.abandonRemotePage() + // Slept with its VM (NEW-01): the tab stays. While asleep it waits; once the workspace is + // open again it opens a new host page at its URL. + if (state.asleepBrowserWorktreeIds[browserTab.worktreeId]) { + clearStreamFrame() + return + } + if (consumeReopenAfterSleep(browserTab.id)) { + clearStreamFrame() + lifecycle.open() + return + } if (remoteViewportTimerRef.current !== null) { window.clearTimeout(remoteViewportTimerRef.current) remoteViewportTimerRef.current = null @@ -166,6 +178,7 @@ export function useRemoteBrowserPageLifecycle({ [ browserTab.id, browserTab.workspaceId, + browserTab.worktreeId, clearStreamFrame, closeBrowserPage, closeBrowserTab, diff --git a/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx b/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx index 6d86e12acc1..3a806702159 100644 --- a/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx +++ b/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx @@ -1,4 +1,3 @@ -import { useReopenRemoteDesktopAfterWake } from '@/lib/cloud-remote-desktop/desktop-sleep-reopen' import React, { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react' import { toast } from 'sonner' import { useAppStore } from '@/store' @@ -224,7 +223,6 @@ function useInertSiblings(cover: React.RefObject, active: bo function CloudSurface({ workspaceId }: { workspaceId: string }): React.JSX.Element | null { const t = useTranslate() const view = useCloudWorkspaceView(workspaceId) - useReopenRemoteDesktopAfterWake(workspaceId, view.state === 'running') const name = useAppStore((state) => findWorktreeById(state, workspaceId)?.displayName ?? null) // Ready means the server answers; the pill stays ("Connecting…") until the pane in front has // re-attached and can take keys. diff --git a/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts b/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts index 8a5776cdf3a..f42f7b6c13d 100644 --- a/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts +++ b/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts @@ -11,6 +11,8 @@ const mocks = vi.hoisted(() => { activeWorktreeId: null, setActiveWorktree: vi.fn(), shutdownWorktreeBrowsers: vi.fn(), + browserTabsByWorktree: {}, + browserPagesByWorkspace: {}, shutdownWorktreeTerminals: vi.fn(), tabsByWorktree, ptyIdsByTabId, @@ -18,9 +20,14 @@ const mocks = vi.hoisted(() => { detectedWorktreesByRepo: {} }, persist: vi.fn(async () => {}), - payload: vi.fn(() => ({})) + payload: vi.fn(() => ({})), + evictGuests: vi.fn() } }) +vi.mock('@/store/slices/browser/cleanup/browser-webview-cleanup', () => ({ + destroyWorktreeBrowserGuests: (_tabs: unknown, _pages: unknown, worktreeId: string) => + mocks.evictGuests(worktreeId) +})) vi.mock('@/store', () => ({ useAppStore: { getState: () => mocks.state, subscribe: () => () => {} } })) @@ -203,7 +210,9 @@ describe('project move renderer completion', () => { records: [] }) await f.persist() - expect(mocks.state.shutdownWorktreeBrowsers).toHaveBeenCalledWith('wt') + // Sleep keeps the tabs (NEW-01); only their pages are dropped. + expect(mocks.state.shutdownWorktreeBrowsers).not.toHaveBeenCalled() + expect(mocks.evictGuests).toHaveBeenCalledWith('wt') expect(f.responses.at(-1)).toMatchObject({ phase: 'error', error: 'project_move_pause_sleep_superseded' diff --git a/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx b/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx index 469c7cf90fa..990f23049c5 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx +++ b/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { useCallback, useEffect, useMemo, useRef, useState } from 'react' import { useAppStore } from '@/store' import { useRepoById } from '@/store/repos/use-repository-catalog' @@ -107,7 +108,11 @@ export function useWorktreeContextMenuModel({ selectMenuScopedMap(menuOpen, s.ptyIdsByTabId, EMPTY_PTY_IDS_BY_TAB_ID) ) const browserTabsByWorktree = useAppStore((s) => - selectMenuScopedMap(menuOpen, s.browserTabsByWorktree, EMPTY_BROWSER_TABS_BY_WORKTREE) + selectMenuScopedMap( + menuOpen, + selectAwakeBrowserTabsByWorktree(s), + EMPTY_BROWSER_TABS_BY_WORKTREE + ) ) const unifiedTabsByWorktree = useAppStore((s) => selectMenuScopedMap(menuOpen, s.unifiedTabsByWorktree, EMPTY_UNIFIED_TABS_BY_WORKTREE) diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts new file mode 100644 index 00000000000..c83180025f3 --- /dev/null +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts @@ -0,0 +1,102 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' +import type { BrowserWorkspace } from '../../../../../../shared/browser-workspace-types' + +type State = { + activeWorktreeId: string | null + browserTabsByWorktree: Record + asleepBrowserWorktreeIds: Record + browserPagesByWorkspace: Record + activeBrowserTabIdByWorktree: Record +} + +const mocks = vi.hoisted(() => { + const listeners = new Set<(state: State) => void>() + const initial: State = { + activeWorktreeId: null, + browserTabsByWorktree: {}, + asleepBrowserWorktreeIds: {}, + browserPagesByWorkspace: {}, + activeBrowserTabIdByWorktree: {} + } + const store = { + state: initial, + getState: (): State => store.state, + setState: (change: (state: State) => Partial): void => { + store.state = { ...store.state, ...change(store.state) } + for (const listener of listeners) { + listener(store.state) + } + }, + subscribe: (listener: (state: State) => void): (() => void) => { + listeners.add(listener) + return () => listeners.delete(listener) + } + } + const evicted: string[] = [] + return { store, evicted } +}) +vi.mock('@/store', () => ({ useAppStore: mocks.store })) +vi.mock('@/store/slices/browser/cleanup/browser-webview-cleanup', () => ({ + destroyWorktreeBrowserGuests: (_tabs: unknown, _pages: unknown, worktreeId: string) => + mocks.evicted.push(worktreeId) +})) + +const { sleepWorktreeBrowserTabs, installBrowserTabWakeOnOpen, selectAwakeBrowserTabsByWorktree } = + await import('./browser-tab-sleep') +const { isInactiveWorkspace } = await import('@/lib/worktree-activity-state') + +const tab = (id: string): BrowserWorkspace => ({ + id, + worktreeId: 'wt', + url: `http://localhost:3000/${id}`, + title: id, + loading: false, + faviconUrl: null, + canGoBack: false, + canGoForward: false, + loadError: null, + createdAt: 1 +}) + +const state = (): State => mocks.store.getState() +const inactive = (): boolean => + isInactiveWorkspace('wt', {}, {}, selectAwakeBrowserTabsByWorktree(state()), new Set()) + +beforeEach(() => { + mocks.evicted.length = 0 + mocks.store.state = { + activeWorktreeId: null, + browserTabsByWorktree: { wt: [tab('a'), tab('b'), tab('c')] }, + asleepBrowserWorktreeIds: {}, + browserPagesByWorkspace: {}, + activeBrowserTabIdByWorktree: { wt: 'b' } + } +}) + +describe('sleep keeps browser tabs in place (NEW-01)', () => { + it('keeps every tab, in order, with the same active tab; drops only their pages', () => { + const before = state().browserTabsByWorktree + sleepWorktreeBrowserTabs('wt', 42) + expect(mocks.evicted).toEqual(['wt']) + // The layout itself is untouched: same object, same order, same active tab. + expect(state().browserTabsByWorktree).toBe(before) + expect(state().browserTabsByWorktree.wt.map((t) => t.id)).toEqual(['a', 'b', 'c']) + expect(state().activeBrowserTabIdByWorktree.wt).toBe('b') + }) + + it('asleep tabs are not activity, so the workspace still reads as asleep', () => { + expect(inactive()).toBe(false) + sleepWorktreeBrowserTabs('wt', 42) + expect(inactive()).toBe(true) + }) + + it('opening the workspace again wakes its tabs', () => { + const stop = installBrowserTabWakeOnOpen() + sleepWorktreeBrowserTabs('wt', 42) + mocks.store.setState(() => ({ activeWorktreeId: 'wt' })) + expect(state().asleepBrowserWorktreeIds).toEqual({}) + expect(inactive()).toBe(false) + expect(state().browserTabsByWorktree.wt.map((t) => t.id)).toEqual(['a', 'b', 'c']) + stop() + }) +}) diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts new file mode 100644 index 00000000000..fc62a3a8d2e --- /dev/null +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts @@ -0,0 +1,103 @@ +// Sleep never changes a workspace's tab layout (NEW-01). Its browser tabs stay where they are, in +// the same order with the same active tab; only their pages are dropped to free memory, and the +// workspace's tabs are marked asleep so they no longer count as activity (an asleep workspace still +// reads as asleep and hides with "Hide sleeping"). Opening the workspace again wakes them: each +// page reloads in place when it is shown. A remote desktop tab's own chrome reconnects it after a +// wake. The mark lives outside the layout (asleepBrowserWorktreeIds), so sleep writes no layout. +import { useAppStore } from '@/store' +import { destroyWorktreeBrowserGuests } from '@/store/slices/browser/cleanup/browser-webview-cleanup' +import type { BrowserWorkspace } from '../../../../../../shared/browser-workspace-types' + +type BrowserTabsByWorktree = Record + +let cache: { + tabs: BrowserTabsByWorktree + asleep: Record + awake: BrowserTabsByWorktree +} | null = null + +/** + * The browser tabs that count as activity: every workspace's, minus those Sleep put to rest. + * Same object back while neither input changes, so store selectors stay stable. + */ +export function selectAwakeBrowserTabsByWorktree(state: { + browserTabsByWorktree: BrowserTabsByWorktree + asleepBrowserWorktreeIds?: Record +}): BrowserTabsByWorktree { + const tabs = state.browserTabsByWorktree + const asleep = state.asleepBrowserWorktreeIds + if (!asleep || Object.keys(asleep).length === 0) { + return tabs + } + if (cache && cache.tabs === tabs && cache.asleep === asleep) { + return cache.awake + } + const awake: BrowserTabsByWorktree = {} + for (const [worktreeId, worktreeTabs] of Object.entries(tabs)) { + if (!asleep[worktreeId]) { + awake[worktreeId] = worktreeTabs + } + } + cache = { tabs, asleep, awake } + return awake +} + +// Pages a host ran (an Orca Cloud VM's browser) are gone after the VM sleeps. When such a page is +// reported missing after the wake, its tab opens a new page at the same URL instead of closing. +const reopenAfterSleep = new Set() + +/** True once per slept page: the pane recreates the host page instead of closing the tab. */ +export function consumeReopenAfterSleep(browserPageId: string): boolean { + return reopenAfterSleep.delete(browserPageId) +} + +/** Sleep: drop the pages, keep the tabs, mark the workspace's tabs asleep. */ +export function sleepWorktreeBrowserTabs(worktreeId: string, now: number = Date.now()): void { + const state = useAppStore.getState() + for (const tab of state.browserTabsByWorktree[worktreeId] ?? []) { + reopenAfterSleep.add(tab.id) + for (const page of state.browserPagesByWorkspace[tab.id] ?? []) { + reopenAfterSleep.add(page.id) + } + } + destroyWorktreeBrowserGuests( + state.browserTabsByWorktree, + state.browserPagesByWorkspace, + worktreeId + ) + if ((state.browserTabsByWorktree[worktreeId] ?? []).length === 0) { + return + } + useAppStore.setState((s) => ({ + asleepBrowserWorktreeIds: { ...s.asleepBrowserWorktreeIds, [worktreeId]: now } + })) +} + +/** The workspace is open again: its tabs count as activity once more (pages reload when shown). */ +export function wakeWorktreeBrowserTabs(worktreeId: string): void { + if (!useAppStore.getState().asleepBrowserWorktreeIds?.[worktreeId]) { + return + } + useAppStore.setState((s) => { + const next = { ...s.asleepBrowserWorktreeIds } + delete next[worktreeId] + return { asleepBrowserWorktreeIds: next } + }) +} + +/** Wakes a workspace's asleep tabs whenever it becomes the active one. */ +export function installBrowserTabWakeOnOpen(): () => void { + let previous = useAppStore.getState().activeWorktreeId + if (previous) { + wakeWorktreeBrowserTabs(previous) + } + return useAppStore.subscribe((state) => { + if (state.activeWorktreeId === previous) { + return + } + previous = state.activeWorktreeId + if (previous) { + wakeWorktreeBrowserTabs(previous) + } + }) +} diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts index f60b120aefa..f434606caa5 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts @@ -18,6 +18,8 @@ type SleepStateInput = { tabsByWorktree?: Record | null ptyIdsByTabId?: Record | null browserTabsByWorktree?: Record | null + /** Workspaces whose browser tabs Sleep put to rest: those tabs are not activity. */ + asleepBrowserWorktreeIds?: Record unifiedTabsByWorktree?: Record | null structuredChatSleptAtByPaneKey?: StructuredChatSleptAtByPaneKey } @@ -70,7 +72,7 @@ export function selectIsSleepingWorktree(state: SleepStateInput, worktreeId: str worktreeId, state.tabsByWorktree, state.ptyIdsByTabId, - state.browserTabsByWorktree, + state.asleepBrowserWorktreeIds?.[worktreeId] ? null : state.browserTabsByWorktree, selectWorktreeIdsWithLiveAgent(state), getWorktreeIdsWithStructuredChat( state.unifiedTabsByWorktree, diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts index ba14d165b55..8dabfd1cb24 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts @@ -1,5 +1,5 @@ import { useAppStore } from '@/store' -import { noteRemoteDesktopBeforeSleep } from '@/lib/cloud-remote-desktop/desktop-sleep-reopen' +import { sleepWorktreeBrowserTabs, wakeWorktreeBrowserTabs } from './browser-tab-sleep' import { captureWorkspaceSelection, restoreWorkspaceSelection, @@ -56,10 +56,6 @@ export function followWorkspaceSleep( const state = useAppStore.getState() const wasActive = state.activeWorktreeId === worktreeId const selectionBeforeSleep = wasActive ? captureWorkspaceSelection(state) : null - if (!options.keepBrowserTabs) { - // Before the selection clears: whether the desktop tab was in front decides how it comes back. - noteRemoteDesktopBeforeSleep(worktreeId) - } // Why first: clearing the active workspace unmounts its panes, whose exits must not stamp activity. markWorktreeSleepIntent(worktreeId) if (wasActive) { @@ -68,7 +64,9 @@ export function followWorkspaceSleep( restoreSidebarPosition() } if (!options.keepBrowserTabs) { - state.shutdownWorktreeBrowsers(worktreeId) + // Sleep never changes the tab layout (NEW-01): the tabs, their order and the active one stay; + // only their pages are dropped, and each reloads in place when shown after the wake. + sleepWorktreeBrowserTabs(worktreeId) } let settle!: (stop: HostTerminalStop) => void const hostStop = new Promise((resolve) => (settle = resolve)) @@ -105,6 +103,8 @@ export function followWorkspaceSleep( // A failed sleep leaves the workspace awake and retryable; one the user reopened is theirs. if (!notice.slept || state.activeWorktreeId === worktreeId) { clearWorktreeSleepIntent(worktreeId) + // Still awake: its tabs count as activity again. + wakeWorktreeBrowserTabs(worktreeId) } if (!notice.slept && entry?.selectionBeforeSleep && state.activeWorktreeId === null) { restoreWorkspaceSelection(state, entry.selectionBeforeSleep) diff --git a/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts b/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts index 936433e3ba7..cda31867815 100644 --- a/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts +++ b/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { useMemo, useState } from 'react' import { useAppStore } from '@/store' import { getAgentStatusEpochNow } from '@/lib/agent-status/evidence/agent-status-epoch-clock' @@ -52,7 +53,7 @@ export function useVisibleWorkspaceKanbanWorktreeIds({ const tabsByWorktree = useAppStore((s) => (!showSleepingWorkspaces ? s.tabsByWorktree : null)) const ptyIdsByTabId = useAppStore((s) => (!showSleepingWorkspaces ? s.ptyIdsByTabId : null)) const browserTabsByWorktree = useAppStore((s) => - !showSleepingWorkspaces ? s.browserTabsByWorktree : null + !showSleepingWorkspaces ? selectAwakeBrowserTabsByWorktree(s) : null ) const worktreeIdsWithStructuredChat = useAppStore((s) => getStructuredChatWorktreeIds( diff --git a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts index a3902e3bac9..f77a9d28fd2 100644 --- a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts +++ b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts @@ -62,7 +62,12 @@ export function selectWorktreeActivityPtyIds( export function useWorktreeActivityStatus(worktreeId: string): WorktreeStatus { const tabs = useAppStore((s) => s.tabsByWorktree[worktreeId] ?? EMPTY_TABS) - const browserTabs = useAppStore((s) => s.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS) + // Tabs Sleep put to rest stay in the layout but are not activity (NEW-01). + const browserTabs = useAppStore((s) => + s.asleepBrowserWorktreeIds?.[worktreeId] + ? EMPTY_BROWSER_TABS + : (s.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS) + ) const hasStructuredChat = useAppStore((s) => hasAwakeStructuredChat(s.unifiedTabsByWorktree[worktreeId], s.structuredChatSleptAtByPaneKey) ) diff --git a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts index b6fc9e5a473..1ddf10432e9 100644 --- a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts +++ b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts @@ -35,7 +35,9 @@ export function selectWorktreeActivityStatuses( worktreeId, resolveWorktreeStatus({ tabs: statusInputs.tabsByWorktree[worktreeId] ?? EMPTY_TABS, - browserTabs: statusInputs.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS, + browserTabs: statusInputs.asleepBrowserWorktreeIds?.[worktreeId] + ? EMPTY_BROWSER_TABS + : (statusInputs.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS), hasStructuredChat: hasAwakeStructuredChat( statusInputs.unifiedTabsByWorktree[worktreeId], statusInputs.structuredChatSleptAtByPaneKey diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts b/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts index 5539a3a3193..c7fa50c2a9a 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts @@ -19,6 +19,8 @@ export type VisibleWorktreeOptions = { tabsByWorktree: Record[]> | null ptyIdsByTabId: Record | null browserTabsByWorktree?: Record | null + /** Workspaces whose browser tabs Sleep put to rest: those tabs are not activity (NEW-01). */ + asleepBrowserWorktreeIds?: Record worktreeIdsWithLiveAgent: ReadonlySet worktreeIdsWithStructuredChat?: ReadonlySet hideDefaultBranchWorkspace: boolean diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts b/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts index bbf8798e922..e0fe22d7fe3 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts @@ -23,6 +23,7 @@ export type DesktopWorkspaceRowFactInputs = { tabsByWorktree: Record[]> | null ptyIdsByTabId: Record | null browserTabsByWorktree?: Record | null + asleepBrowserWorktreeIds?: Record worktreeIdsWithLiveAgent: ReadonlySet worktreeIdsWithStructuredChat?: ReadonlySet /** Rows in a PTY-rebind grace window; read as unverifiable, never as asleep (#15996). */ @@ -54,7 +55,7 @@ export function buildDesktopWorkspaceRowFactReader( worktree.id, inputs.tabsByWorktree, inputs.ptyIdsByTabId, - inputs.browserTabsByWorktree, + inputs.asleepBrowserWorktreeIds?.[worktree.id] ? null : inputs.browserTabsByWorktree, inputs.worktreeIdsWithLiveAgent, inputs.worktreeIdsWithStructuredChat ) diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts b/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts index dbb9ad4bcf6..300bd07cc4d 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import type { AppState } from '@/store/types' import type { Worktree } from '../../../../../../shared/worktree/types' import { isSleepingSweepExempt } from '../../../../../../shared/workspace-view/workspace-row-filters' @@ -15,7 +16,9 @@ export function createSleepingSweepHiddenCheck( exemptWorktreeIds?: ReadonlySet ): (worktree: Worktree) => boolean { const tabsByWorktree = getVisibleWorktreeTerminalActivityTabs(state.tabsByWorktree) - const browserTabsByWorktree = getVisibleWorktreeBrowserActivityTabs(state.browserTabsByWorktree) + const browserTabsByWorktree = getVisibleWorktreeBrowserActivityTabs( + selectAwakeBrowserTabsByWorktree(state) + ) const liveAgentWorktrees = getWorktreeIdsWithLiveAgent( state.agentStatusByPaneKey, tabsByWorktree, diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts index c33f953ca27..4f3de102ea5 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { selectSidebarLineageParentIdentities } from '@/store/slices/worktrees/metadata/cross-store-lineage-parents' import { useMemo, useState } from 'react' import { shallow } from 'zustand/shallow' @@ -93,7 +94,9 @@ export function useVisibleSidebarWorktrees(args: { ) const ptyIdsByTabId = useAppStore((s) => (needsActivityMaps ? s.ptyIdsByTabId : null)) const browserTabsByWorktree = useAppStore((s) => - !showSleepingWorkspaces ? getVisibleWorktreeBrowserActivityTabs(s.browserTabsByWorktree) : null + !showSleepingWorkspaces + ? getVisibleWorktreeBrowserActivityTabs(selectAwakeBrowserTabsByWorktree(s)) + : null ) const worktreeIdsWithStructuredChat = useAppStore((s) => getStructuredChatWorktreeIds( diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts index cdfb00e5052..c3500996b40 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts @@ -21,6 +21,7 @@ export function buildVisibleWorktreeOptionsFromState( tabsByWorktree: state.tabsByWorktree, ptyIdsByTabId: state.ptyIdsByTabId, browserTabsByWorktree: state.browserTabsByWorktree, + asleepBrowserWorktreeIds: state.asleepBrowserWorktreeIds, worktreeIdsWithLiveAgent: getWorktreeIdsWithLiveAgent( state.agentStatusByPaneKey, state.tabsByWorktree, diff --git a/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts b/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts index cee10a49f5c..1204fc6c808 100644 --- a/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts +++ b/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts @@ -2,6 +2,7 @@ import { createRuntimeFilePositionQueue } from './runtime-file-position' import { applyClosedTerminalLeafNotice } from '@/components/terminal-pane/layout/close/closed-terminal-leaf-notice' import { closeTerminalTab } from '@/components/terminal/terminal-tab-actions' import { detectLanguage } from '../../../../shared/editor-language/editor-language-detect' +import { installBrowserTabWakeOnOpen } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { followWorkspaceSleep } from '@/components/sidebar/workspace-actions/sleep/workspace-sleep-follower' import { createProjectMovePauseFollower } from '@/components/sidebar/project-move-pause-follower' import { buildWorkspaceSessionPayload } from '@/lib/workspace/persistence/workspace-session' @@ -218,6 +219,8 @@ export function registerMobileAndTerminalCloseIpcBridge( } else { unsubs.push(window.api.ui.onWorkspaceSleep(followWorkspaceSleep)) } + // Sleep keeps a workspace's browser tabs asleep in place; opening it again wakes them. + unsubs.push(installBrowserTabWakeOnOpen()) unsubs.push( window.api.ui.onResumeSleepingAgents(({ worktreeId }) => { diff --git a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts b/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts deleted file mode 100644 index aae8d67601d..00000000000 --- a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { beforeEach, describe, expect, it, vi } from 'vitest' - -const DESKTOP = 'http://localhost:6080/vnc.html?autoconnect=0&reconnect=0&resize=remote' -let state: Record = {} -const reopen = vi.fn(async () => {}) - -vi.mock('@/store', () => ({ useAppStore: { getState: () => state } })) -vi.mock('@/lib/workspace/ownership/workspace-runtime-environment', () => ({ - selectWorkspaceRuntimeEnvironmentId: () => 'env-1', - useWorkspaceRuntimeEnvironmentId: () => 'env-1' -})) -vi.mock('./open-cloud-remote-desktop', () => ({ - reopenCloudRemoteDesktopQuietly: reopen, - openCloudRemoteDesktop: vi.fn() -})) -vi.mock('react', () => ({ - useEffect: (fn: () => void) => fn(), - useMemo: (fn: () => unknown) => fn() -})) - -const { - hasRemoteDesktopToReopen, - noteRemoteDesktopBeforeSleep, - resetRemoteDesktopSleepReopenForTest, - useReopenRemoteDesktopAfterWake -} = await import('./desktop-sleep-reopen') - -describe('remote desktop across sleep', () => { - beforeEach(() => { - resetRemoteDesktopSleepReopenForTest() - reopen.mockClear() - }) - - it('remembers a desktop tab that sleep closes and reopens it once the workspace runs', () => { - state = { - activeWorktreeId: 'w1', - activeTabType: 'browser', - activeBrowserTabId: 'tab-d', - browserTabsByWorktree: { - w1: [ - { id: 'tab-b', url: 'https://example.com' }, - { id: 'tab-d', url: DESKTOP } - ] - } - } - noteRemoteDesktopBeforeSleep('w1') - expect(hasRemoteDesktopToReopen('w1')).toBe(true) - useReopenRemoteDesktopAfterWake('w1', false) - expect(reopen).not.toHaveBeenCalled() - useReopenRemoteDesktopAfterWake('w1', true) - expect(reopen).toHaveBeenCalledWith('w1', 'env-1', true) - // Once only. - useReopenRemoteDesktopAfterWake('w1', true) - expect(reopen).toHaveBeenCalledTimes(1) - }) - - it('reopens a desktop that was behind another tab without bringing it to the front', () => { - state = { - activeWorktreeId: 'w1', - activeTabType: 'terminal', - activeBrowserTabId: null, - browserTabsByWorktree: { w1: [{ id: 'tab-d', url: DESKTOP }] } - } - noteRemoteDesktopBeforeSleep('w1') - useReopenRemoteDesktopAfterWake('w1', true) - expect(reopen).toHaveBeenCalledWith('w1', 'env-1', false) - }) - - it('does nothing for a workspace without a desktop tab', () => { - state = { browserTabsByWorktree: { w1: [{ id: 'tab-b', url: 'http://localhost:3000/' }] } } - noteRemoteDesktopBeforeSleep('w1') - expect(hasRemoteDesktopToReopen('w1')).toBe(false) - }) -}) diff --git a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts b/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts deleted file mode 100644 index 266971a9600..00000000000 --- a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { useEffect } from 'react' -import { useAppStore } from '@/store' -import { selectWorkspaceRuntimeEnvironmentId } from '@/lib/workspace/ownership/workspace-runtime-environment' -import { selectRemoteDesktopTabId } from './remote-desktop-tab' -import { reopenCloudRemoteDesktopQuietly } from './open-cloud-remote-desktop' - -// Sleep closes a workspace's browser tabs (workspace-sleep-follower.ts), and the desktop's processes -// stop with the sandbox anyway. A remote desktop tab is remembered here and comes back on its own -// once the workspace is awake, in front again if it was in front. -const sleptWithDesktop = new Map() - -/** Call before sleep tears down the workspace's browser tabs. */ -export function noteRemoteDesktopBeforeSleep(worktreeId: string): void { - const state = useAppStore.getState() - const tabId = selectRemoteDesktopTabId(state, worktreeId) - if (!tabId) { - return - } - sleptWithDesktop.set(worktreeId, { - wasInFront: - state.activeWorktreeId === worktreeId && - state.activeTabType === 'browser' && - state.activeBrowserTabId === tabId - }) -} - -/** Reopens it when the workspace is running again (mounted for the workspace on screen). */ -export function useReopenRemoteDesktopAfterWake(worktreeId: string, running: boolean): void { - useEffect(() => { - const entry = running ? sleptWithDesktop.get(worktreeId) : undefined - if (!entry) { - return - } - sleptWithDesktop.delete(worktreeId) - const environmentId = selectWorkspaceRuntimeEnvironmentId(useAppStore.getState(), worktreeId) - if (environmentId) { - void reopenCloudRemoteDesktopQuietly(worktreeId, environmentId, entry.wasInFront) - } - }, [running, worktreeId]) -} - -export function hasRemoteDesktopToReopen(worktreeId: string): boolean { - return sleptWithDesktop.has(worktreeId) -} - -export function resetRemoteDesktopSleepReopenForTest(): void { - sleptWithDesktop.clear() -} diff --git a/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx b/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx index 3a7d9d69887..61a460b0adc 100644 --- a/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx +++ b/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx @@ -139,23 +139,6 @@ function showDesktopTab( }) } -/** - * Reopens a desktop tab that sleep closed, once the workspace is awake again: no toasts (the tab's - * own state says how it goes) and it only comes to the front if it was in front when it slept. - */ -export function reopenCloudRemoteDesktopQuietly( - worktreeId: string, - environmentId: string, - activate: boolean -): Promise { - return exclusive(worktreeId, async () => { - const result = await requestCloudRemoteDesktop(environmentId) - if (result.ok) { - showDesktopTab(worktreeId, environmentId, result.url, activate) - } - }) -} - /** One open or wake at a time per workspace: a second click while one runs does nothing. */ async function exclusive(worktreeId: string, work: () => Promise): Promise { if (typeof window.api?.ephemeralVm?.openCloudRemoteDesktop !== 'function') { diff --git a/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts b/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts index 3b233e81f7d..4d93f604c34 100644 --- a/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts +++ b/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts @@ -26,6 +26,7 @@ export function readWindowWorkspaceActivityFacts( | 'tabsByWorktree' | 'ptyIdsByTabId' | 'browserTabsByWorktree' + | 'asleepBrowserWorktreeIds' | 'unifiedTabsByWorktree' | 'agentStatusByPaneKey' > & @@ -55,7 +56,8 @@ export function readWindowWorkspaceActivityFacts( ) ? 'live' : null, - browser: (state.browserTabsByWorktree[id]?.length ?? 0) > 0, + browser: + !state.asleepBrowserWorktreeIds?.[id] && (state.browserTabsByWorktree[id]?.length ?? 0) > 0, structuredChat: structuredChatIds.has(id), agent: agentById.get(id) ?? null } diff --git a/src/renderer/src/store/slices/browser/browser-slice-contract.ts b/src/renderer/src/store/slices/browser/browser-slice-contract.ts index fe5f62d6496..8b28afd32ee 100644 --- a/src/renderer/src/store/slices/browser/browser-slice-contract.ts +++ b/src/renderer/src/store/slices/browser/browser-slice-contract.ts @@ -116,6 +116,8 @@ export type BrowserCookieImportExecutionResult = BrowserCookieImportResult & { export type BrowserSlice = { browserTabsByWorktree: Record + /** Workspaces whose tabs Sleep put to rest (when): kept in the layout, not activity (NEW-01). */ + asleepBrowserWorktreeIds: Record browserPagesByWorkspace: Record browserCertificateFailuresByPageId: Record /** May precede the page record (client-hosted pages); main's false on guest teardown clears it. */ diff --git a/src/renderer/src/store/slices/browser/create-browser-slice.ts b/src/renderer/src/store/slices/browser/create-browser-slice.ts index 080e4561564..519b168186f 100644 --- a/src/renderer/src/store/slices/browser/create-browser-slice.ts +++ b/src/renderer/src/store/slices/browser/create-browser-slice.ts @@ -23,6 +23,7 @@ import { createBrowserHistoryActions } from './history/browser-history-actions' export const createBrowserSlice: StateCreator = (set, get) => ({ browserTabsByWorktree: {}, + asleepBrowserWorktreeIds: {}, browserPagesByWorkspace: {}, browserCertificateFailuresByPageId: {}, browserAudiblePageIds: {},