ds-harness-remote-fast/apps/android/tests/session-instant-open.test.ts

256 lines
11 KiB
TypeScript

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)
})
})