diff --git a/apps/android/tests/session-instant-open.test.ts b/apps/android/tests/session-instant-open.test.ts new file mode 100644 index 0000000..3134d9f --- /dev/null +++ b/apps/android/tests/session-instant-open.test.ts @@ -0,0 +1,255 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' +import type { ChatItem, ChatMessage, HistoryEntry, RemoteSession } from '../src/types' +import { browseKey, browseScope, saveSessionMessagesSnapshot, useBrowseMemory } from '../src/services/browse-memory' + +const { proxy, transport, storage, authenticate, acp, codex } = vi.hoisted(() => ({ + proxy: { + sessionHistory: vi.fn(), messageFeedbackList: vi.fn(), sessionModels: vi.fn(), + sessionList: vi.fn(), sessionCreate: vi.fn(), hostDescribe: vi.fn(), workspaceList: vi.fn(), + workspaceArchiveSession: vi.fn(), sessionSelectPermission: vi.fn(), sessionPrompt: vi.fn(), sessionUpdateQueue: vi.fn(), + }, + transport: { + connect: vi.fn(), close: vi.fn(), checkHealth: vi.fn(), refreshBackends: vi.fn(), + hasCodex: vi.fn(), hasCursor: vi.fn(), hasAntigravity: vi.fn(), hasPi: vi.fn(), + hasOpencode: vi.fn(), hasClaude: vi.fn(), hasHermes: vi.fn(), requireClaude: vi.fn(), requireHermes: vi.fn(), + }, + acp: { + call: vi.fn(), transferCall: vi.fn(), openStream: vi.fn(), prompt: vi.fn(), + sessionModels: vi.fn(), selectModel: vi.fn(), archiveSession: vi.fn(), createSession: vi.fn(), + }, + storage: { + saveRecentWorkspaces: vi.fn(), saveLastConnectedDeviceId: vi.fn(), loadCodexPermissionPresets: vi.fn(), saveCodexPermissionPreset: vi.fn(), + }, + codex: { request: vi.fn(), subscribe: vi.fn() }, + authenticate: vi.fn(), +})) + +vi.mock('expo-haptics', () => ({ impactAsync: async () => undefined, ImpactFeedbackStyle: { Light: 'light' } })) +vi.mock('../src/services/network-route', () => ({ resolveAutomaticPreferredTransports: async () => ['relay'] })) +vi.mock('../src/services/connection', () => ({ + AndroidRemoteConnection: class { + async configureHistory() {} + requireProxy() { return proxy } + connect = transport.connect + close = transport.close + checkHealth = transport.checkHealth + refreshBackends = transport.refreshBackends + hasCodex = transport.hasCodex + requireCodex() { return codex } + hasCursor = transport.hasCursor + hasPi = transport.hasPi + hasAntigravity = transport.hasAntigravity + hasOpencode = transport.hasOpencode + hasClaude = transport.hasClaude + hasHermes = transport.hasHermes + requireCursor() { return acp } + requireAntigravity() { return acp } + requirePi() { return acp } + requireOpencode() { return acp } + requireClaude() { transport.requireClaude(); return acp } + requireHermes() { transport.requireHermes(); return acp } + getNetworkDetails() { return Promise.resolve(undefined) } + getStats() { return { mode: 'Relay', connected: true } } + }, +})) +vi.mock('../src/services/storage', () => storage) +vi.mock('../src/services/login', () => ({})) +vi.mock('../src/services/server-session', () => ({ serverSession: { authenticate } })) + +import { useAppStore } from '../src/state/store' + +const harnessSession: RemoteSession = { + sessionId: 's-harness', backend: 'harness', updatedAt: 10, running: false, blank: false, +} + +const hermesSession: RemoteSession = { + sessionId: 'hermes:s-hermes', nativeId: 's-hermes', backend: 'hermes', updatedAt: 20, running: false, blank: false, +} + +const codexSession: RemoteSession = { + sessionId: 'codex:s-codex', nativeId: 's-codex', backend: 'codex', updatedAt: 30, running: false, blank: false, +} + +const cachedMsg: ChatItem = { + id: 'cached-1', sessionId: 's-harness', kind: 'message', role: 'assistant', text: 'Cached offline message', createdAt: 1000, +} + +describe('Session Instant Open & Flicker-free Realignment', () => { + beforeEach(() => { + vi.resetAllMocks() + transport.checkHealth.mockResolvedValue(true) + transport.hasCodex.mockReturnValue(true) + transport.hasHermes.mockReturnValue(true) + acp.openStream.mockResolvedValue({ streamId: 'stream-1', close: async () => undefined }) + codex.subscribe.mockResolvedValue({ streamId: 'codex-stream-1', close: async () => undefined }) + proxy.sessionList.mockResolvedValue([harnessSession]) + proxy.workspaceList.mockResolvedValue({ items: [], archivedSessionIds: [] }) + proxy.hostDescribe.mockResolvedValue({}) + storage.loadCodexPermissionPresets.mockResolvedValue({}) + useBrowseMemory.setState({ + entries: {}, catalogs: {}, hostModes: {}, resume: false, notifications: true, autoConnectHost: true, ready: true, + }) + useAppStore.setState({ + ...useAppStore.getInitialState(), + selectedDevice: { deviceId: 'dev-1', identityKey: 'key-1' } as never, + config: { baseUrl: 'https://example.com', account: 'test' }, + sessions: [harnessSession, hermesSession, codexSession], + connection: { phase: 'connected', stats: { mode: 'Relay', connected: true } }, + }) + }) + + it('instant open in offline/disconnected mode renders cached messages immediately and enables read-only', async () => { + const store = useAppStore.getState() + const scope = browseScope(store) + saveSessionMessagesSnapshot(scope, 's-harness', [cachedMsg]) + + useAppStore.setState({ + connection: { phase: 'offline', stats: { mode: 'Disconnected', connected: false } }, + selectedSession: undefined, + messages: {}, + }) + + const opened = await useAppStore.getState().openSession(harnessSession) + expect(opened).toBe(true) + + const state = useAppStore.getState() + expect(state.selectedSession?.sessionId).toBe('s-harness') + expect(state.messages['s-harness']).toBeDefined() + expect(state.messages['s-harness']).toHaveLength(1) + expect((state.messages['s-harness']![0] as ChatMessage).text).toBe('Cached offline message') + expect(state.busyAction).toBeUndefined() + }) + + it('connected Harness openSession retains existing/cached messages while authoritative history loads and in-place merges', async () => { + let resolveHistory!: (val: unknown) => void + const historyPromise = new Promise(resolve => { resolveHistory = resolve }) + proxy.sessionHistory.mockReturnValue(historyPromise) + proxy.messageFeedbackList.mockResolvedValue([]) + + const scope = browseScope(useAppStore.getState()) + saveSessionMessagesSnapshot(scope, 's-harness', [cachedMsg]) + + useAppStore.setState({ + selectedSession: undefined, + messages: {}, + }) + + const openPromise = useAppStore.getState().openSession(harnessSession) + + // Synchronously, the cached message is already on screen (no white flash!) + const intermediateState = useAppStore.getState() + expect(intermediateState.selectedSession?.sessionId).toBe('s-harness') + expect(intermediateState.messages['s-harness']).toBeDefined() + expect((intermediateState.messages['s-harness']![0] as ChatMessage).text).toBe('Cached offline message') + expect(intermediateState.busyAction).toBe('session:s-harness') + + // Authoritative history returns from Host + const authEvent: HistoryEntry = { + event: { + type: 'user/message', seq: 2, time: 2000, + data: { message: { role: 'user', content: [{ type: 'text', text: 'Authoritative prompt' }] } }, + }, + } + resolveHistory({ events: [authEvent], throughSeq: 2, hasMore: false }) + const ok = await openPromise + expect(ok).toBe(true) + + const finalState = useAppStore.getState() + expect(finalState.busyAction).toBeUndefined() + expect(finalState.messages['s-harness']).toBeDefined() + // Authoritative message in-place replaced without gap + expect(finalState.messages['s-harness']!.some(m => m.kind === 'message' && (m as ChatMessage).text.includes('Authoritative prompt'))).toBe(true) + + // Snapshot is updated in browse memory + const cached = useBrowseMemory.getState().entries[browseKey(scope, 's-harness')]?.messages + expect(cached).toBeDefined() + expect(cached!.some(m => m.kind === 'message' && (m as ChatMessage).text.includes('Authoritative prompt'))).toBe(true) + }) + + it('ACP backend (Hermes) openSession preserves existing messages without clearing to []', async () => { + let resolveAcpHistory!: (val: unknown) => void + const acpHistoryPromise = new Promise(resolve => { resolveAcpHistory = resolve }) + acp.transferCall.mockReturnValue(acpHistoryPromise) + + const existingLiveMsg: ChatItem = { + id: 'live-1', sessionId: 'hermes:s-hermes', kind: 'message', role: 'user', text: 'In flight hermes prompt', createdAt: 3000, + } + + useAppStore.setState({ + selectedSession: hermesSession, + messages: { 'hermes:s-hermes': [existingLiveMsg] }, + }) + + const openPromise = useAppStore.getState().openSession(hermesSession) + + // The live message must NOT be cleared to [] while history is pending + const intermediateState = useAppStore.getState() + expect(intermediateState.messages['hermes:s-hermes']).toBeDefined() + expect(intermediateState.messages['hermes:s-hermes']).toHaveLength(1) + expect((intermediateState.messages['hermes:s-hermes']![0] as ChatMessage).text).toBe('In flight hermes prompt') + + // Resolve ACP history + resolveAcpHistory({ + events: [ + { + event: { + type: 'user/message', seq: 1, time: 1000, + data: { message: { role: 'user', content: [{ type: 'text', text: 'Old Hermes message' }] } }, + }, + }, + ], + }) + + await openPromise + const finalState = useAppStore.getState() + expect(finalState.messages['hermes:s-hermes']).toBeDefined() + expect(finalState.messages['hermes:s-hermes']!.length).toBeGreaterThanOrEqual(1) + }) + + it('Codex backend openSession retains cached messages and merges in-place', async () => { + let resolveCodexPage!: (val: unknown) => void + const codexPagePromise = new Promise(resolve => { resolveCodexPage = resolve }) + const thread = { id: 's-codex', cwd: '/project', status: { type: 'active', activeFlags: [] }, createdAt: 1, updatedAt: 2 } + codex.request.mockImplementation(async (method: string) => { + if (method === 'thread/read') return { thread } + if (method === 'dsh/sessionHistory') return codexPagePromise + return {} + }) + + const scope = browseScope(useAppStore.getState()) + const codexCached: ChatItem = { + id: 'codex-c1', sessionId: 'codex:s-codex', kind: 'message', role: 'assistant', text: 'Codex cached text', createdAt: 1000, + } + saveSessionMessagesSnapshot(scope, 'codex:s-codex', [codexCached]) + + useAppStore.setState({ + selectedSession: undefined, + messages: {}, + }) + + const openPromise = useAppStore.getState().openSession(codexSession) + + // Cached message is immediately visible + expect(useAppStore.getState().messages['codex:s-codex']).toBeDefined() + expect((useAppStore.getState().messages['codex:s-codex']![0] as ChatMessage).text).toBe('Codex cached text') + + // Authoritative history resolves + resolveCodexPage({ + header: { id: 'codex:s-codex' }, + records: [ + { + type: 'event', + event: { + type: 'user/message', seq: 1, time: 2000, + data: { message: { role: 'user', content: [{ type: 'text', text: 'Authoritative Codex prompt' }] } }, + }, + }, + ], + hasMore: false, + }) + + await openPromise + const finalState = useAppStore.getState() + expect(finalState.messages['codex:s-codex']!.some(m => m.kind === 'message' && (m as ChatMessage).text.includes('Authoritative Codex prompt'))).toBe(true) + }) +})