ds-harness-remote-fast/apps/android/tests/fast-browse.test.ts

453 lines
24 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from 'vitest'
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
import type { AppState, StoreAccess } from '../src/state/store-state'
import type { HistoryEntry, RemoteSession } from '../src/types'
import { backendGroups, browseStatus } from '../src/lib/backend-groups'
import { foldHistory } from '../src/state/event-reducer'
const { client, proxy } = vi.hoisted(() => ({
client: { request: vi.fn(), subscribe: vi.fn(), configureHistory: vi.fn() },
proxy: {
sessionHistory: vi.fn(),
messageFeedbackList: vi.fn(),
sessionPrompt: vi.fn(),
workspacePinSession: vi.fn(),
workspaceUnpinSession: vi.fn(),
workspaceArchiveSession: vi.fn(),
workspaceUnarchiveSession: vi.fn(),
sessionRename: vi.fn(),
sessionFork: vi.fn(),
sessionList: vi.fn(),
workspaceList: vi.fn(),
},
}))
vi.mock('expo-haptics', () => ({ impactAsync: vi.fn(), ImpactFeedbackStyle: { Light: 'light' } }))
vi.mock('../src/services/storage', () => ({ loadCodexPermissionPresets: async () => ({}), saveCodexPermissionPreset: vi.fn(), saveRecentWorkspaces: vi.fn() }))
vi.mock('../src/services/remote-runtime', () => ({ AndroidRemoteRuntime: class {
async configureHistory(value: boolean) { await client.configureHistory(value) }
requireCodex() { return client }
requireProxy() { return proxy }
} }))
import { SessionRuntime } from '../src/state/session-runtime'
import { createSessionActions } from '../src/state/session-actions'
import { createPromptActions } from '../src/state/prompt-actions'
import { saveCodexPermissionPreset } from '../src/services/storage'
function deferred<T>() {
let resolve!: (value: T) => void, reject!: (error: Error) => void
const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no })
return { promise, resolve, reject }
}
const tick = async () => { for (let i = 0; i < 12; i++) await Promise.resolve() }
const thread = (id: string) => ({ id, cwd: '/fixture', name: id, createdAt: 1, updatedAt: 1, status: { type: 'idle' }, turns: [] })
const session = (id: string, codex = true): RemoteSession => ({ sessionId: codex ? `codex:${id}` : id, nativeId: id,
backend: codex ? 'codex' : 'harness', updatedAt: 1, running: false, blank: false,
projections: { values: { remoteStatusKnown: true, codexStatus: 'idle' } } })
const event = (seq: number): HistoryEntry => ({ event: { type: 'assistant/message', seq, time: seq * 1000,
data: { turn: seq, message: { id: `m${seq}`, content: [{ type: 'text', text: `message ${seq}` }] } } } })
const page = (id: string, seqs = [20], hasMore = false) => ({ header: { id: `codex:${id}` },
records: seqs.map(seq => ({ type: 'event', ...event(seq) })), hasMore })
let state: AppState, runtime: SessionRuntime, access: StoreAccess
function prepareScenario() {
vi.resetAllMocks()
state = { connection: { phase: 'connected' }, selectedDevice: { deviceId: 'host' }, sessions: [], messages: {},
sessionLifecycles: {}, feedbackBySession: {}, currentWorkSessionIds: [], historyHasMore: false, historyLoadingOlder: false,
handleCodexFrame: vi.fn(), reconnect: vi.fn(async () => false) } as unknown as AppState
access = { get: () => state, set: change => { state = { ...state, ...(typeof change === 'function' ? change(state) : change) } } }
runtime = new SessionRuntime(access)
runtime.rememberRecentWorkspace = vi.fn(async () => undefined)
runtime.refreshCodexModels = vi.fn(async () => undefined)
runtime.refreshSessionModels = vi.fn(async () => undefined)
Object.assign(state, createSessionActions({ ...access, runtime }), createPromptActions({ ...access, runtime }))
client.request.mockImplementation(async (method, args) => method === 'thread/read' ? { thread: thread(args.threadId) } : page(args.threadId))
client.subscribe.mockImplementation(async () => ({ close: vi.fn(async () => undefined) }))
proxy.messageFeedbackList.mockResolvedValue([])
proxy.sessionHistory.mockResolvedValue({ events: [event(20)], hasMore: false })
}
beforeEach(prepareScenario)
describe('Codex permission inheritance', () => {
const policy = (preset: string) => ({approvalPolicy: preset === 'danger-full-access' ? 'never' : 'on-request', sandbox: preset})
async function openWithCachedPermission(preset: string) {
const target = session('a')
target.projections!.values!.permissions = {currentValue: preset}
state.sessions = [target]
expect(await state.openSession(target)).toBe(true)
}
it('inherits the Host permission when the phone cached a different preset', async () => {
await runScenarios(['workspace-write', 'danger-full-access'].map(cached => ({name: cached, run: async () => {
await openWithCachedPermission(cached)
const original = cached === 'workspace-write' ? 'danger-full-access' : 'workspace-write'
let effective = original
client.request.mockImplementation(async (method, args) => {
if (args.permissionPreset !== undefined) effective = args.permissionPreset
if (method === 'thread/resume') return {thread: thread('a'), ...policy(effective)}
return {turn: {id: 'next', status: 'inProgress'}}
})
client.request.mockClear()
expect(await state.sendMessage('continue')).toBe('sent')
expect(client.request.mock.calls.map(([method]) => method)).toEqual(['thread/resume', 'turn/start'])
for (const [, args] of client.request.mock.calls) expect(args).not.toHaveProperty('permissionPreset')
expect(effective).toBe(original)
expect(state.selectedSession?.projections?.values?.permissions).toMatchObject({currentValue: original})
expect(state.sessions[0]?.projections?.values?.permissions).toMatchObject({currentValue: original})
}})), prepareScenario)
})
it('applies an explicit phone selection and inherits it on the following send', async () => {
await runScenarios(['workspace-write', 'danger-full-access'].map(selected => ({name: selected, run: async () => {
let effective = selected === 'workspace-write' ? 'danger-full-access' : 'workspace-write'
await openWithCachedPermission(effective)
client.request.mockImplementation(async (method, args) => {
if (args.permissionPreset !== undefined) effective = args.permissionPreset
if (method === 'thread/resume') return {thread: thread('a'), ...policy(effective)}
return {turn: {id: 'next', status: 'inProgress'}}
})
client.request.mockClear()
expect(await state.selectPermission(selected)).toBe(true)
expect(client.request).toHaveBeenCalledWith('thread/resume', {threadId: 'a', permissionPreset: selected})
expect(saveCodexPermissionPreset).toHaveBeenCalledWith('host', 'a', selected)
expect(await state.sendMessage('continue')).toBe('sent')
expect(client.request.mock.calls.filter(([, args]) => args.permissionPreset !== undefined)).toHaveLength(1)
expect(effective).toBe(selected)
expect(state.selectedSession?.projections?.values?.permissions).toMatchObject({currentValue: selected})
}})), prepareScenario)
})
})
describe('fast browsing without changing writer ownership', () => {
it('reconfigures global history mode before reads and invalidates pagination across mode changes', async () => {
const target = session('a')
state.compactHistory = false
await state.openSession(target)
state.messages[target.sessionId] = foldHistory([event(1), event(20)], target.sessionId, true)
state.oldestLoadedSeq = 1
state.historyHasMore = true
state.compactHistory = true
const configure = deferred<void>()
client.configureHistory.mockReturnValueOnce(configure.promise)
const previousReads = client.request.mock.calls.length
const opening = state.openSession(target)
await tick()
expect(client.request.mock.calls).toHaveLength(previousReads)
configure.resolve()
expect(await opening).toBe(true)
expect(state.messages[target.sessionId]?.map(item => item.id)).toEqual(['m20'])
expect(state.oldestLoadedSeq).toBe(20)
expect(state.historyHasMore).toBe(false)
state.compactHistory = false
expect(await state.openSession(target)).toBe(true)
expect(client.configureHistory.mock.calls).toEqual([[false], [true], [false]])
expect(state.messages[target.sessionId]?.map(item => item.id)).toEqual(['m20'])
})
it('shows cached content synchronously and reads while previous unsubscribe is blocked', async () => {
const a = session('a'), oldClose = deferred<void>(), fresh = deferred<ReturnType<typeof page>>()
state.sessions = [a]; state.messages[a.sessionId] = foldHistory([event(20)], a.sessionId, true)
runtime.activeCodexStream = { close: vi.fn(() => oldClose.promise) } as never
client.request.mockImplementation(async (method, args) => method === 'thread/read' ? { thread: thread(args.threadId) } : fresh.promise)
const pending = state.openSession(a)
expect(state.selectedSession?.sessionId).toBe(a.sessionId)
expect(state.messages[a.sessionId]?.length).toBe(1)
expect(await state.sendMessage('do not dispatch')).toBe('rejected')
expect(proxy.sessionPrompt).not.toHaveBeenCalled()
await tick()
expect(client.request).toHaveBeenCalledWith('dsh/sessionHistory', { threadId: 'a', maxMessages: 16 }, expect.any(AbortSignal))
fresh.resolve(page('a', [20, 21])); expect(await pending).toBe(true)
expect(state.messages[a.sessionId]?.length).toBe(2)
expect(client.request.mock.calls.map(c => c[0])).not.toContain('thread/resume')
oldClose.resolve()
})
it('renders a cold history page before new subscription acknowledgement', async () => {
const subscribe = deferred<{ close: () => Promise<void> }>()
client.subscribe.mockReturnValue(subscribe.promise)
const a = session('a'), pending = state.openSession(a)
expect(state.selectedSession?.sessionId).toBe(a.sessionId)
await tick()
expect(state.messages[a.sessionId]?.length).toBe(1)
expect(state.busyAction).toBe(`session:${a.sessionId}`)
expect(await state.sendMessage('not yet')).toBe('rejected')
subscribe.resolve({ close: async () => undefined }); expect(await pending).toBe(true)
expect(state.busyAction).toBeUndefined()
})
it.each(['success', 'failure'] as const)('ignores retired history %s after A to B switching', async outcome => {
const delayed = deferred<ReturnType<typeof page>>(), a = session('a'), b = session('b')
client.request.mockImplementation(async (method, args) => method === 'thread/read' ? { thread: thread(args.threadId) }
: args.threadId === 'a' ? delayed.promise : page('b'))
const openingA = state.openSession(a); await tick()
const signal = client.request.mock.calls.find(c => c[0] === 'dsh/sessionHistory')![2] as AbortSignal
expect(await state.openSession(b)).toBe(true)
expect(signal.aborted).toBe(true)
if (outcome === 'success') delayed.resolve(page('a')); else delayed.reject(new Error('late failure'))
expect(await openingA).toBe(false)
expect(state.selectedSession?.sessionId).toBe(b.sessionId)
expect(state.messages[a.sessionId]).toBeUndefined()
expect(state.error).toBeUndefined()
expect(client.subscribe.mock.calls.map(c => c[0])).toEqual(['b'])
})
it('closes a late obsolete subscription without closing the current subscription', async () => {
const delayed = deferred<{ close: () => Promise<void> }>(), oldClose = vi.fn(async () => undefined), newClose = vi.fn(async () => undefined)
client.subscribe.mockImplementation(async id => id === 'a' ? delayed.promise : { close: newClose })
const a = state.openSession(session('a')); await tick()
expect(await state.openSession(session('b'))).toBe(true)
delayed.resolve({ close: oldClose }); expect(await a).toBe(false)
expect(oldClose).toHaveBeenCalledOnce(); expect(newClose).not.toHaveBeenCalled()
expect(runtime.activeCodexStream?.close).toBe(newClose)
})
it('rejects sends after subscription failure until the same session is reopened successfully', async () => {
const a = session('a')
client.subscribe.mockRejectedValueOnce(Object.assign(new Error('Too many Codex streams'), { code: 'RATE_LIMITED' }))
expect(await state.openSession(a)).toBe(false)
expect(state.selectedSession?.sessionId).toBe(a.sessionId)
expect(state.messages[a.sessionId]?.length).toBe(1)
expect(state.busyAction).toBeUndefined()
expect(state.codexReadySessionId).toBeUndefined()
const beforeSend = state.messages[a.sessionId]
client.request.mockClear()
expect(await state.sendMessage('must not start unseen work')).toBe('rejected')
expect(client.request).not.toHaveBeenCalled()
expect(state.messages[a.sessionId]).toBe(beforeSend)
expect(await state.openSession(a)).toBe(true)
expect(state.codexReadySessionId).toBe(a.sessionId)
expect(await state.sendMessage('now subscribed')).toBe('sent')
expect(client.request).toHaveBeenCalledWith('turn/start', expect.objectContaining({ threadId: 'a' }))
const onClose = client.subscribe.mock.calls.at(-1)![3] as (reason: string) => void
onClose('failed')
expect(state.codexReadySessionId).toBeUndefined()
client.request.mockClear()
expect(await state.sendMessage('stream closed')).toBe('rejected')
expect(client.request).not.toHaveBeenCalled()
})
it.each([true, false])('keeps cached pagination only with overlapping history: %s', async overlap => {
const a = session('a'), b = session('b')
state.selectedSession = a; state.sessions = [a, b]
state.messages[a.sessionId] = foldHistory([event(1), event(20)], a.sessionId, true)
state.oldestLoadedSeq = 1; state.historyHasMore = false
await state.openSession(b)
client.request.mockImplementation(async (method, args) => method === 'thread/read' ? { thread: thread(args.threadId) } : page('a', overlap ? [20, 21] : [40, 41], true))
await state.openSession(a)
expect(state.oldestLoadedSeq).toBe(overlap ? 1 : 40)
expect(state.historyHasMore).toBe(!overlap)
expect(state.messages[a.sessionId]?.length).toBe(overlap ? 3 : 2)
if (!overlap) {
client.request.mockResolvedValueOnce(page('a', [30, 31], true))
await state.loadOlderHistory()
expect(state.oldestLoadedSeq).toBe(30)
expect(state.messages[a.sessionId]?.length).toBe(4)
}
})
it.each(['success', 'failure'] as const)('discards older-page %s after changing host generation', async outcome => {
const a = session('a'), delayed = deferred<ReturnType<typeof page>>()
state.selectedSession = a; state.oldestLoadedSeq = 20; state.historyHasMore = true
client.request.mockReturnValue(delayed.promise)
const pending = state.loadOlderHistory()
runtime.connectionGeneration++
state.selectedDevice = { deviceId: 'another-host' } as never
state.messages = {}; state.historyLoadingOlder = false; state.error = 'new host'
if (outcome === 'success') delayed.resolve(page('a', [1])); else delayed.reject(new Error('old host'))
await pending
expect(state.messages).toEqual({}); expect(state.error).toBe('new host')
expect(state.historyLoadingOlder).toBe(false)
})
it('DSH switches without waiting for Codex unsubscribe, and remains send-blocked until fresh history', async () => {
const old = deferred<void>(), history = deferred<{ events: HistoryEntry[]; hasMore: boolean }>()
runtime.activeCodexStream = { close: () => old.promise } as never
proxy.sessionHistory.mockReturnValue(history.promise)
const a = session('dsh', false), pending = state.openSession(a)
expect(state.selectedSession?.sessionId).toBe('dsh')
await tick()
expect(proxy.sessionHistory).toHaveBeenCalled()
expect(await state.sendMessage('not yet')).toBe('rejected')
history.resolve({ events: [event(20)], hasMore: false }); expect(await pending).toBe(true)
expect(state.messages.dsh?.length).toBe(1); old.resolve()
})
it('recovers a read timeout only once with a new abort scope', async () => {
const a = session('a'), timeout = Object.assign(new Error('RPC timed out'), { code: 'RPC_TIMEOUT' })
client.request.mockRejectedValue(timeout)
state.reconnect = vi.fn(async () => { runtime.connectionGeneration++; runtime.sessionLoadGeneration++; runtime.sessionReadAbort?.abort(); return true })
expect(await state.openSession(a)).toBe(false)
expect(state.reconnect).toHaveBeenCalledTimes(1)
expect(state.error).toBeDefined()
})
it('does not reopen an abandoned conversation after a delayed reconnect', async () => {
const reconnect = deferred<boolean>(), timeout = Object.assign(new Error('RPC timed out'), { code: 'RPC_TIMEOUT' })
client.request.mockRejectedValue(timeout)
state.reconnect = vi.fn(() => reconnect.promise)
const old = state.openSession(session('a')); await tick()
expect(state.reconnect).toHaveBeenCalledOnce()
client.request.mockImplementation(async (method, args) => method === 'thread/read' ? { thread: thread(args.threadId) } : page(args.threadId))
expect(await state.openSession(session('b'))).toBe(true)
reconnect.resolve(true); expect(await old).toBe(false)
expect(state.selectedSession?.sessionId).toBe('codex:b')
expect(client.subscribe.mock.calls.map(c => c[0])).toEqual(['b'])
})
})
describe('backend separated conversation drawer', () => {
it('isolates same-named workspaces, unassigned sessions and recent lists', () => {
const c = session('c'), active = { ...session('active'), running: true }, unknown = { ...session('unknown'), running: true, projections: {values: {remoteStatusKnown: false}} }
const h = session('h', false), loose = session('loose', false), archived = session('archived')
const input = { workspaces: [
{ workspaceId: 'same', title: 'Same name', backend: 'codex' as const, path: '/same', sessionIds: [c.sessionId, active.sessionId, unknown.sessionId, archived.sessionId], createdAt: '', updatedAt: '' },
{ workspaceId: 'same', title: 'Same name', backend: 'harness' as const, path: '/same', sessionIds: [h.sessionId], createdAt: '', updatedAt: '' },
], sessions: [c, active, unknown, h, loose, archived], archived: [archived.sessionId], recent: [h.sessionId, c.sessionId, unknown.sessionId], lifecycles: {} }
const codex = backendGroups({ ...input, backend: 'codex' })
expect(codex.flatMap(g => g.sessions).every(s => s.backend === 'codex')).toBe(true)
expect(codex.flatMap(g => g.sessions)).not.toContain(archived)
expect(codex.find(g => g.key === 'recent:codex')?.sessions.map(s => s.sessionId)).toEqual([unknown.sessionId, c.sessionId])
const harness = backendGroups({ ...input, backend: 'harness' })
expect(harness.flatMap(g => g.sessions).every(s => s.backend === 'harness')).toBe(true)
expect(harness.find(g => g.key === 'unassigned:harness')?.sessions).toEqual([loose])
expect(browseStatus({...unknown, projections: {values: {remoteStatusKnown: false}}}, { running: false })).toBe('unknown')
expect(browseStatus(h, { running: true })).toBe('running')
})
})
describe('session pin, unpin, rename, unarchive, and fork actions', () => {
beforeEach(() => {
prepareScenario()
})
it('pins a session and updates pinnedSessionIds in store', async () => {
proxy.workspacePinSession.mockResolvedValueOnce(['h-1'])
const ok = await state.pinSession('h-1')
expect(ok).toBe(true)
expect(proxy.workspacePinSession).toHaveBeenCalledWith('h-1')
expect(state.pinnedSessionIds).toEqual(['h-1'])
})
it('unpins a session and updates pinnedSessionIds in store', async () => {
state.pinnedSessionIds = ['h-1', 'h-2']
proxy.workspaceUnpinSession.mockResolvedValueOnce(['h-2'])
const ok = await state.unpinSession('h-1')
expect(ok).toBe(true)
expect(proxy.workspaceUnpinSession).toHaveBeenCalledWith('h-1')
expect(state.pinnedSessionIds).toEqual(['h-2'])
})
it('unarchives a session and updates archivedSessionIds in store', async () => {
state.archivedSessionIds = ['h-1']
proxy.workspaceUnarchiveSession.mockResolvedValueOnce([])
const ok = await state.unarchiveSession('h-1')
expect(ok).toBe(true)
expect(proxy.workspaceUnarchiveSession).toHaveBeenCalledWith('h-1')
expect(state.archivedSessionIds).toEqual([])
})
it('renames a session and updates the title in sessions and selectedSession', async () => {
const s1 = session('s1', false)
state.sessions = [s1]
state.selectedSession = s1
proxy.sessionRename.mockResolvedValueOnce({ title: 'New Renamed Title', seq: 5 })
const ok = await state.renameSession('s1', ' New Renamed Title ')
expect(ok).toBe(true)
expect(proxy.sessionRename).toHaveBeenCalledWith('s1', 'New Renamed Title')
expect(state.sessions.find(s => s.sessionId === 's1')?.title).toBe('New Renamed Title')
expect(state.selectedSession?.title).toBe('New Renamed Title')
})
it('rejects empty title for rename without calling host', async () => {
const ok = await state.renameSession('s1', ' ')
expect(ok).toBe(false)
expect(proxy.sessionRename).not.toHaveBeenCalled()
})
it('forks a session at latest state and opens the child session', async () => {
const s1 = session('s1', false)
const forked = { ...session('forked-1', false), title: 'Forked Conversation' }
state.sessions = [s1]
proxy.sessionFork.mockResolvedValueOnce({ sessionId: 'forked-1' })
proxy.sessionList.mockResolvedValueOnce([s1, forked])
proxy.workspaceList.mockResolvedValueOnce({
items: [],
archivedSessionIds: [],
pinnedSessionIds: ['s1'],
})
const result = await state.forkSession('s1')
expect(result?.sessionId).toBe('forked-1')
expect(proxy.sessionFork).toHaveBeenCalledWith('s1')
expect(state.sessions).toContainEqual(forked)
expect(state.pinnedSessionIds).toEqual(['s1'])
})
it('preserves non-harness sessions and workspaces when forking a harness session', async () => {
const codexSession = { ...session('codex-1', false), backend: 'codex' as const }
const harnessSession = { ...session('harness-1', false), backend: 'harness' as const }
const forkedHarness = { ...session('harness-forked', false), backend: 'harness' as const }
state.sessions = [codexSession, harnessSession]
state.workspaces = [
{
workspaceId: 'ws-codex',
title: 'Codex WS',
path: '/codex',
backend: 'codex' as const,
sessionIds: ['codex-1'],
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
},
{
workspaceId: 'ws-harness',
title: 'Harness WS',
path: '/harness',
backend: 'harness' as const,
sessionIds: ['harness-1'],
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
},
]
proxy.sessionFork.mockResolvedValueOnce({ sessionId: 'harness-forked' })
proxy.sessionList.mockResolvedValueOnce([harnessSession, forkedHarness])
proxy.workspaceList.mockResolvedValueOnce({
items: [
{
workspaceId: 'ws-harness',
title: 'Harness WS',
path: '/harness',
backend: 'harness' as const,
sessionIds: ['harness-1', 'harness-forked'],
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
},
],
archivedSessionIds: [],
pinnedSessionIds: [],
})
const result = await state.forkSession('harness-1')
expect(result?.sessionId).toBe('harness-forked')
expect(state.sessions).toContainEqual(codexSession)
expect(state.sessions).toContainEqual(forkedHarness)
expect(state.workspaces.some(w => w.workspaceId === 'ws-codex')).toBe(true)
})
it('refuses to pin or rename non-harness sessions without invoking host proxy', async () => {
const codexSession = { ...session('codex-1', false), backend: 'codex' as const }
state.sessions = [codexSession]
const pinOk = await state.pinSession('codex-1')
expect(pinOk).toBe(false)
expect(proxy.workspacePinSession).not.toHaveBeenCalled()
const renameOk = await state.renameSession('codex-1', 'New Title')
expect(renameOk).toBe(false)
expect(proxy.sessionRename).not.toHaveBeenCalled()
})
})