diff --git a/src/main/persistence.test.ts b/src/main/persistence.test.ts index 43f94be0942..2e9e279b4ff 100644 --- a/src/main/persistence.test.ts +++ b/src/main/persistence.test.ts @@ -9377,6 +9377,58 @@ describe('Store', () => { // ── Live Claude PTY session ids (STA-1246) ───────────────────────── + describe('mobileClientTabSelectionsByDeviceId', () => { + it('persists device tab selections across reloads and drops malformed payloads', async () => { + const store = await createStore() + store.setMobileClientTabSelections({ + 'device-a': { + 'repo-1::/tmp/wt': { activeTabId: 'tab-1', activeGroupId: 'g1', activeTabIdByGroupId: {} } + } + }) + store.flush() + + const reloaded = await createStore() + expect(reloaded.getMobileClientTabSelections()['device-a']?.['repo-1::/tmp/wt']).toEqual({ + activeTabId: 'tab-1', + activeGroupId: 'g1', + activeTabIdByGroupId: {} + }) + + writeDataFile({ mobileClientTabSelectionsByDeviceId: { 'device-a': 'corrupt' } }) + const corrupted = await createStore() + expect(corrupted.getMobileClientTabSelections()).toEqual({}) + }) + + it('prunes selections for a removed repo worktree', async () => { + const store = await createStore() + store.addRepo(makeRepo()) + store.setMobileClientTabSelections({ + 'device-a': { + 'r1::/tmp/wt': { + activeTabId: 'tab-1', + activeGroupId: null, + activeTabIdByGroupId: {} + }, + 'other-repo::/tmp/wt': { + activeTabId: 'tab-2', + activeGroupId: null, + activeTabIdByGroupId: {} + } + } + }) + + store.removeProject('r1') + + expect(store.getMobileClientTabSelections()['device-a']).toEqual({ + 'other-repo::/tmp/wt': { + activeTabId: 'tab-2', + activeGroupId: null, + activeTabIdByGroupId: {} + } + }) + }) + }) + describe('claudeLivePtySessionIds', () => { it('persists added ids across reloads and removes them durably', async () => { const store = await createStore() diff --git a/src/main/persistence.ts b/src/main/persistence.ts index aba79a4561c..99f9ed8c075 100644 --- a/src/main/persistence.ts +++ b/src/main/persistence.ts @@ -48,6 +48,7 @@ import type { ProjectGroup, FolderWorkspace, SparsePreset, + PersistedMobileClientTabSelections, WorktreeMeta, WorktreeLineage, WorkspaceLineage, @@ -77,6 +78,7 @@ import { } from '../shared/task-source-context' import type { MigrationUnsupportedPtyEntry } from '../shared/agent-status-types' import { MOBILE_PAIRING_USERDATA_FILES } from './runtime/mobile-pairing-files' +import { normalizePersistedMobileClientTabSelections } from './runtime/client-session-tab-selection' import { hardenExistingSecureFile } from '../shared/secure-file' import { LEGACY_DEFAULT_SSH_RELAY_GRACE_PERIOD_SECONDS, @@ -3004,6 +3006,9 @@ export class Store { normalizedProjectGroups ), worktreeLineageById: parsed.worktreeLineageById ?? {}, + mobileClientTabSelectionsByDeviceId: normalizePersistedMobileClientTabSelections( + parsed.mobileClientTabSelectionsByDeviceId + ), workspaceLineageByChildKey: normalizeWorkspaceLineageByChildKey( parsed.workspaceLineageByChildKey ), @@ -4199,6 +4204,15 @@ export class Store { delete this.state.workspaceLineageByChildKey[childKey as WorkspaceKey] } } + for (const selectionsByWorktree of Object.values( + this.state.mobileClientTabSelectionsByDeviceId ?? {} + )) { + for (const key of Object.keys(selectionsByWorktree)) { + if (belongsToHost(key)) { + delete selectionsByWorktree[key] + } + } + } } updateRepo( @@ -4438,6 +4452,17 @@ export class Store { // ── Sparse Presets ───────────────────────────────────────────────── + // ── Mobile client tab selections ────────────────────────────────── + + getMobileClientTabSelections(): PersistedMobileClientTabSelections { + return this.state.mobileClientTabSelectionsByDeviceId ?? {} + } + + setMobileClientTabSelections(next: PersistedMobileClientTabSelections): void { + this.state.mobileClientTabSelectionsByDeviceId = next + this.scheduleSave() + } + getSparsePresets(repoId: string): SparsePreset[] { return [...(this.state.sparsePresetsByRepo[repoId] ?? [])].sort((left, right) => left.name.localeCompare(right.name) diff --git a/src/main/runtime/client-session-tab-selection.test.ts b/src/main/runtime/client-session-tab-selection.test.ts index c75ffd2ac78..bdb0b869057 100644 --- a/src/main/runtime/client-session-tab-selection.test.ts +++ b/src/main/runtime/client-session-tab-selection.test.ts @@ -1,9 +1,11 @@ import { describe, expect, it } from 'vitest' import type { RuntimeMobileSessionTabsResult } from '../../shared/runtime-types' +import type { PersistedMobileClientTabSelections } from '../../shared/types' import { activateClientSessionTabSelection, ClientSessionTabSelectionStore, deriveClientSessionTabSelection, + normalizePersistedMobileClientTabSelections, projectClientSessionTabSelection } from './client-session-tab-selection' @@ -138,4 +140,75 @@ describe('client session-tab selection', () => { expect(projected.activeGroupId).toBe('group-left') expect(projected.tabs.find((tab) => tab.isActive)?.id).toBe('terminal-a::leaf-a') }) + + it('persists activations and restores them across a store rebuild (host restart)', () => { + const persisted: PersistedMobileClientTabSelections[] = [] + const store = new ClientSessionTabSelectionStore() + store.setPersistListener((state) => persisted.push(state)) + + store.activate(snapshot(), 'device-a', 'browser-unified') + + expect(persisted).toHaveLength(1) + expect(persisted[0]?.['device-a']?.['wt-1']?.activeTabId).toBe('browser-unified') + + const restarted = new ClientSessionTabSelectionStore() + restarted.hydrate(persisted[0]!) + const projected = restarted.project(snapshot(), 'device-a') + + expect(projected.activeTabId).toBe('browser-unified') + expect(projected.tabs.find((tab) => tab.isActive)?.id).toBe('browser-unified') + expect(restarted.project(snapshot(), 'device-b').activeTabId).toBe('terminal-a::leaf-a') + }) + + it('persists forgetClient and forgetWorktree removals', () => { + const persisted: PersistedMobileClientTabSelections[] = [] + const store = new ClientSessionTabSelectionStore() + store.activate(snapshot(), 'device-a', 'browser-unified') + store.setPersistListener((state) => persisted.push(state)) + + store.forgetWorktree('wt-1') + expect(persisted.at(-1)).toEqual({}) + + store.activate(snapshot(), 'device-a', 'browser-unified') + store.forgetClient('device-a') + expect(persisted.at(-1)).toEqual({}) + // Why: forgetting state that is already gone must not rewrite the persisted file. + const writes = persisted.length + store.forgetClient('device-a') + store.forgetWorktree('wt-1') + expect(persisted.length).toBe(writes) + }) + + it('does not let an empty snapshot wipe a hydrated selection before tabs arrive', () => { + const store = new ClientSessionTabSelectionStore() + store.hydrate({ + 'device-a': { + 'wt-1': { activeTabId: 'browser-unified', activeGroupId: null, activeTabIdByGroupId: {} } + } + }) + + const empty = { ...snapshot(), tabGroups: [], tabs: [] } + expect(store.project(empty, 'device-a').activeTabId).toBe('terminal-a::leaf-a') + + expect(store.project(snapshot(), 'device-a').activeTabId).toBe('browser-unified') + }) + + it('drops malformed persisted payloads instead of hydrating them', () => { + expect( + normalizePersistedMobileClientTabSelections({ + 'device-a': { + 'wt-1': { activeTabId: 'tab-1', activeGroupId: null, activeTabIdByGroupId: { g: 'tab' } }, + 'wt-bad': { activeTabId: 42, activeGroupId: null, activeTabIdByGroupId: { g: 7 } } + }, + 'device-bad': 'nope', + 'device-empty': {} + }) + ).toEqual({ + 'device-a': { + 'wt-1': { activeTabId: 'tab-1', activeGroupId: null, activeTabIdByGroupId: { g: 'tab' } } + } + }) + expect(normalizePersistedMobileClientTabSelections(null)).toEqual({}) + expect(normalizePersistedMobileClientTabSelections('garbage')).toEqual({}) + }) }) diff --git a/src/main/runtime/client-session-tab-selection.ts b/src/main/runtime/client-session-tab-selection.ts index d3cb60e67b7..595bed0c9b6 100644 --- a/src/main/runtime/client-session-tab-selection.ts +++ b/src/main/runtime/client-session-tab-selection.ts @@ -2,6 +2,7 @@ import type { RuntimeMobileSessionClientTab, RuntimeMobileSessionTabsResult } from '../../shared/runtime-types' +import type { PersistedMobileClientTabSelections } from '../../shared/types' export type ClientSessionTabSelection = { activeTabId: string | null @@ -124,8 +125,90 @@ export function projectClientSessionTabSelection( } } +function normalizeClientSessionTabSelection(raw: unknown): ClientSessionTabSelection | null { + if (typeof raw !== 'object' || raw === null) { + return null + } + const candidate = raw as Partial + const activeTabId = typeof candidate.activeTabId === 'string' ? candidate.activeTabId : null + const activeGroupId = typeof candidate.activeGroupId === 'string' ? candidate.activeGroupId : null + const activeTabIdByGroupId: Record = {} + if (typeof candidate.activeTabIdByGroupId === 'object' && candidate.activeTabIdByGroupId) { + for (const [groupId, tabId] of Object.entries(candidate.activeTabIdByGroupId)) { + if (typeof tabId === 'string') { + activeTabIdByGroupId[groupId] = tabId + } + } + } + if (!activeTabId && !activeGroupId && Object.keys(activeTabIdByGroupId).length === 0) { + return null + } + return { activeTabId, activeGroupId, activeTabIdByGroupId } +} + +// Why: this state comes off disk (and, for remote runtimes, another machine); a bad payload must degrade to "no selection", not throw. +export function normalizePersistedMobileClientTabSelections( + raw: unknown +): PersistedMobileClientTabSelections { + const normalized: PersistedMobileClientTabSelections = {} + if (typeof raw !== 'object' || raw === null) { + return normalized + } + for (const [clientNavigationId, selectionsByWorktree] of Object.entries(raw)) { + if (typeof selectionsByWorktree !== 'object' || selectionsByWorktree === null) { + continue + } + const entries: Record = {} + for (const [worktreeId, selection] of Object.entries(selectionsByWorktree)) { + const normalizedSelection = normalizeClientSessionTabSelection(selection) + if (normalizedSelection) { + entries[worktreeId] = normalizedSelection + } + } + if (Object.keys(entries).length > 0) { + normalized[clientNavigationId] = entries + } + } + return normalized +} + export class ClientSessionTabSelectionStore { private statesByClient = new Map>() + private persistListener: ((state: PersistedMobileClientTabSelections) => void) | null = null + + // Why: selections previously died with the process, so a host restart snapped every phone back to the first tab (deterministic-topology fallback). + hydrate(persisted: PersistedMobileClientTabSelections): void { + for (const [clientNavigationId, selectionsByWorktree] of Object.entries( + normalizePersistedMobileClientTabSelections(persisted) + )) { + const statesByWorktree = this.getStatesByWorktree(clientNavigationId) + for (const [worktreeId, selection] of Object.entries(selectionsByWorktree)) { + statesByWorktree.set(worktreeId, { selection, revision: 0 }) + } + } + } + + setPersistListener(listener: (state: PersistedMobileClientTabSelections) => void): void { + this.persistListener = listener + } + + serialize(): PersistedMobileClientTabSelections { + const persisted: PersistedMobileClientTabSelections = {} + for (const [clientNavigationId, statesByWorktree] of this.statesByClient) { + const entries: Record = {} + for (const [worktreeId, state] of statesByWorktree) { + entries[worktreeId] = state.selection + } + if (Object.keys(entries).length > 0) { + persisted[clientNavigationId] = entries + } + } + return persisted + } + + private persistNow(): void { + this.persistListener?.(this.serialize()) + } private getStatesByWorktree( clientNavigationId: string @@ -151,6 +234,14 @@ export class ClientSessionTabSelectionStore { selection: emptyClientSessionTabSelection(), revision: 0 } + if (snapshot.tabs.length === 0) { + // Why: an empty snapshot has no topology to project; writing it back would wipe a restart-hydrated selection before tabs arrive. + return { + ...snapshot, + publicationEpoch: `${snapshot.publicationEpoch}:client-navigation`, + snapshotVersion: snapshot.snapshotVersion + state.revision + } + } const projected = projectClientSessionTabSelection(snapshot, state.selection) statesByWorktree.set(snapshot.worktree, { selection: projected.selection, @@ -177,19 +268,26 @@ export class ClientSessionTabSelectionStore { selection: activateClientSessionTabSelection(snapshot, state.selection, activeTabId), revision: state.revision + 1 }) + this.persistNow() return this.project(snapshot, clientNavigationId) } forgetClient(clientNavigationId: string): void { - this.statesByClient.delete(clientNavigationId) + if (this.statesByClient.delete(clientNavigationId)) { + this.persistNow() + } } forgetWorktree(worktreeId: string): void { + let changed = false for (const [clientNavigationId, statesByWorktree] of this.statesByClient) { - statesByWorktree.delete(worktreeId) + changed = statesByWorktree.delete(worktreeId) || changed if (statesByWorktree.size === 0) { this.statesByClient.delete(clientNavigationId) } } + if (changed) { + this.persistNow() + } } } diff --git a/src/main/runtime/multi-client-navigation-isolation.integration.test.ts b/src/main/runtime/multi-client-navigation-isolation.integration.test.ts index 3c918f7b4b2..d475d6aa08b 100644 --- a/src/main/runtime/multi-client-navigation-isolation.integration.test.ts +++ b/src/main/runtime/multi-client-navigation-isolation.integration.test.ts @@ -5,6 +5,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest' import WebSocket from 'ws' import { parsePairingCode } from '../../shared/pairing' import type { RuntimeMobileSessionTabsResult } from '../../shared/runtime-types' +import type { PersistedMobileClientTabSelections } from '../../shared/types' import { OrcaRuntimeService } from './orca-runtime' import { decrypt, deriveSharedKey, encrypt, generateKeyPair } from './rpc/e2ee-crypto' import { OrcaRuntimeRpcServer } from './runtime-rpc' @@ -578,4 +579,43 @@ describe('paired runtime navigation isolation', () => { expect(serverOne.hostSelections.tabId).toBe('host-tab') expect(serverTwo.hostSelections.tabId).toBe('host-tab') }) + + it('restores a device tab selection after a runtime restart', async () => { + const persisted: { state: PersistedMobileClientTabSelections } = { state: {} } + const makeStoreWithSelections = () => ({ + ...makeStore(), + getMobileClientTabSelections: () => persisted.state, + setMobileClientTabSelections: (next: PersistedMobileClientTabSelections) => { + persisted.state = next + } + }) + + const first = new OrcaRuntimeService(makeStoreWithSelections() as never) + first.attachWindow(1) + first.markGraphReady(1) + seedSessionTabs(first) + await first.activateMobileSessionTab(`id:${SESSION_WORKTREE_ID}`, 'client-a-tab', undefined, { + notifyClients: false, + clientNavigationId: 'device-a', + navigation: 'caller' + }) + expect(persisted.state['device-a']?.[SESSION_WORKTREE_ID]?.activeTabId).toBe('client-a-tab') + + const restarted = new OrcaRuntimeService(makeStoreWithSelections() as never) + restarted.attachWindow(1) + restarted.markGraphReady(1) + seedSessionTabs(restarted) + const remembered = await restarted.listMobileSessionTabs( + `id:${SESSION_WORKTREE_ID}`, + 'device-a' + ) + expect(remembered.activeTabId).toBe('client-a-tab') + expect(remembered.tabs.find((tab) => tab.isActive)?.id).toBe('client-a-tab') + // Why: an unknown device must still start from deterministic topology, not inherit another device's restored state. + const freshDevice = await restarted.listMobileSessionTabs( + `id:${SESSION_WORKTREE_ID}`, + 'device-b' + ) + expect(freshDevice.activeTabId).toBe('host-tab') + }) }) diff --git a/src/main/runtime/orca-runtime.ts b/src/main/runtime/orca-runtime.ts index 6480b965570..93f89519baa 100644 --- a/src/main/runtime/orca-runtime.ts +++ b/src/main/runtime/orca-runtime.ts @@ -913,6 +913,8 @@ type RuntimeStore = { deleteAutomation?: Store['deleteAutomation'] getSparsePresets?: Store['getSparsePresets'] saveSparsePreset?: Store['saveSparsePreset'] + getMobileClientTabSelections?: Store['getMobileClientTabSelections'] + setMobileClientTabSelections?: Store['setMobileClientTabSelections'] getSettings(): { workspaceDir: string nestWorkspaces: boolean @@ -2766,6 +2768,14 @@ export class OrcaRuntimeService { } ) { this.store = store + // Why: per-device tab selections must survive host restarts, or every phone snaps back to the first tab on return. + const persistedClientTabSelections = store?.getMobileClientTabSelections?.() + if (persistedClientTabSelections) { + this.clientSessionTabSelections.hydrate(persistedClientTabSelections) + } + this.clientSessionTabSelections.setPersistListener((state) => { + this.store?.setMobileClientTabSelections?.(state) + }) if (stats) { this.stats = stats this.agentDetector = new AgentDetector(stats) diff --git a/src/shared/types.ts b/src/shared/types.ts index 3d0b6ca3f53..ae3fa3950bc 100644 --- a/src/shared/types.ts +++ b/src/shared/types.ts @@ -3403,6 +3403,19 @@ export type LegacyPaneKeyAliasEntry = { updatedAt: number } +/** Last tab selection a paired client made in a worktree; restores phone navigation across host restarts. */ +export type PersistedMobileClientTabSelection = { + activeTabId: string | null + activeGroupId: string | null + activeTabIdByGroupId: Readonly> +} + +/** deviceId → worktreeId → selection. */ +export type PersistedMobileClientTabSelections = Record< + string, + Record +> + // ─── Persistence shape ────────────────────────────────────────────── export type PersistedState = { schemaVersion: number @@ -3413,6 +3426,8 @@ export type PersistedState = { folderWorkspaces: FolderWorkspace[] /** Sparse-checkout presets keyed by repoId. */ sparsePresetsByRepo: Record + /** Per paired device last tab selection by worktree; keeps mobile navigation across host restarts. */ + mobileClientTabSelectionsByDeviceId?: PersistedMobileClientTabSelections worktreeMeta: Record worktreeLineageById: Record workspaceLineageByChildKey: Record