128 lines
9.4 KiB
TypeScript
128 lines
9.4 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
import type { AgentAcpClient } from '@dsh-remote/client-core'
|
|
import { loadPiCatalog, mergePiCatalog, readPiHistory, selectPiModel } from '../src/services/pi'
|
|
import { AcpSessionTools } from '../src/services/session-tools'
|
|
import { applyCursorFrame, foldAcpHistory, createPiSession, createPiWorkspace, createAntigravitySession, createAntigravityWorkspace } from '../src/services/cursor'
|
|
import type { ChatItem } from '../src/types'
|
|
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
|
|
|
|
describe('PI ACP client isolation and recovery', () => {
|
|
it('uses independent PI catalog authority and keeps only PI memory across rediscovery', async () => {
|
|
const call = vi.fn(async (method: string) => method === 'dsh/workspaceList'
|
|
? [{ path: '/host/project', title: 'Project' }, { path: 'relative/unsafe' }]
|
|
: { items: [{ conversationId: 'durable', title: 'Saved title', updatedAt: 123 }] })
|
|
const catalog = await loadPiCatalog({ call } as unknown as AgentAcpClient, [createAntigravityWorkspace('/other/backend')])
|
|
expect(call).toHaveBeenCalledWith('dsh/workspaceList', { backend: 'pi' })
|
|
expect(call).toHaveBeenCalledWith('dsh/sessionList', { backend: 'pi', path: '/host/project', limit: 100, prewarm: false })
|
|
expect(call).toHaveBeenCalledTimes(2)
|
|
expect(catalog.workspaces[0]?.workspaceId).toBe('pi:cwd:%2Fhost%2Fproject')
|
|
const blank = createPiSession({ acpSessionId: 'new', cwd: '/host/project' })
|
|
const running = { ...catalog.sessions[0]!, title: 'Old title', running: true }
|
|
const workspace = { ...createPiWorkspace('/host/project'), sessionIds: [blank.sessionId, running.sessionId] }
|
|
const merged = mergePiCatalog(catalog, [workspace, createAntigravityWorkspace('/other/backend')], [blank, running, createAntigravitySession({ acpSessionId: 'durable' })])
|
|
expect(merged.workspaces).toHaveLength(1)
|
|
expect(merged.workspaces[0]?.sessionIds).toEqual(['pi:durable', 'pi:new'])
|
|
expect(merged.sessions).toHaveLength(2)
|
|
expect(merged.sessions.find(item => item.nativeId === 'durable')).toMatchObject({ backend: 'pi', title: 'Saved title', running: true, updatedAt: 123 })
|
|
expect(merged.sessions.find(item => item.nativeId === 'new')).toMatchObject({ blank: true })
|
|
})
|
|
|
|
it('loads bounded PI history and propagates transport failure rather than inventing empty recovery', async () => {
|
|
const transferCall = vi.fn().mockResolvedValueOnce({ events: [{ event: { type: 'user/message' } }] }).mockRejectedValueOnce(new Error('offline'))
|
|
const client = { transferCall } as unknown as AgentAcpClient
|
|
expect(await readPiHistory(client, 'durable')).toHaveLength(1)
|
|
expect(transferCall).toHaveBeenCalledWith('dsh/sessionHistory', { backend: 'pi', sessionId: 'durable' })
|
|
await expect(readPiHistory(client, 'durable')).rejects.toThrow('offline')
|
|
})
|
|
|
|
it('restores Host native tool results through PI history without duplicate activity or lost failures', async () => {
|
|
await runScenarios([false, true].map(isError => ({
|
|
name: isError ? 'failed tool recovery' : 'successful tool recovery',
|
|
run: async () => {
|
|
const events = [
|
|
{ event: { type: 'tool/call', seq: 0, time: 0, data: { callId: 'bash-1', name: 'bash', arguments: '{}' } } },
|
|
{ event: { type: 'tool/result', seq: 1, time: 0, data: { message: {
|
|
role: 'user', source: { kind: 'tool', callId: 'bash-1' }, content: [
|
|
{ type: 'tool-result', toolCallId: 'bash-1', content: [{ type: 'text', text: 'terminal output' }], ...(isError ? { isError: true } : {}) },
|
|
],
|
|
} } } },
|
|
]
|
|
const client = { transferCall: vi.fn(async () => ({ events })) } as unknown as AgentAcpClient
|
|
const restored = foldAcpHistory(await readPiHistory(client, 'durable'), 'pi:durable')
|
|
expect(restored).toHaveLength(1)
|
|
expect(restored[0]).toMatchObject({ kind: 'tool', id: 'bash-1', sessionId: 'pi:durable', toolName: 'bash',
|
|
state: isError ? 'failed' : 'finished', resultDetail: { text: 'terminal output' } })
|
|
const refolded = foldAcpHistory(await readPiHistory(client, 'durable'), 'pi:durable')
|
|
// Upstream has no timestamps; Android may assign a fresh display time.
|
|
expect(refolded.map(({ createdAt, ...item }) => item)).toEqual(restored.map(({ createdAt, ...item }) => item))
|
|
},
|
|
})))
|
|
})
|
|
|
|
it('keeps PI permission handles and bounded terminal deltas across tool updates without changing other backends', async () => {
|
|
await runScenarios(['pi', 'cursor', 'antigravity'].flatMap(backend => [0, 2].map(exitCode => ({ name: `${backend}: exit ${exitCode}`, run: () => {
|
|
const sessionId = `${backend}:native`
|
|
const frame = (update: Record<string, unknown>) => ({ streamId: 's', frame: { method: 'session/update', params: { update } } })
|
|
let messages: ChatItem[] = applyCursorFrame([], sessionId, { streamId: 's', frame: {
|
|
method: 'session/request_permission', params: { requestHandle: 'opaque', toolCall: {
|
|
title: 'Execute command', rawInput: { method: 'confirm', message: 'Run bash in /host/project?' },
|
|
}, options: [{ optionId: 'once', kind: 'allow_once' }] },
|
|
} })
|
|
expect(messages[0]).toMatchObject({ kind: 'approval', approvalId: 'opaque', toolName: 'Execute command', reason: 'Run bash in /host/project?' })
|
|
messages = applyCursorFrame(messages, sessionId, frame({ sessionUpdate: 'tool_call', toolCallId: 'bash', title: 'bash' }))
|
|
for (const data of ['a'.repeat(16_001), 'tail']) {
|
|
messages = applyCursorFrame(messages, sessionId, frame({ sessionUpdate: 'tool_call_update', toolCallId: 'bash', _meta: { terminal_output: { data } } }))
|
|
}
|
|
const tool = messages[1]
|
|
expect(tool?.kind).toBe('tool')
|
|
if (tool?.kind !== 'tool') throw new Error('Missing tool')
|
|
expect(tool.state).toBe('running')
|
|
expect(tool.resultDetail?.text).toBe(backend === 'pi' ? `${'a'.repeat(15_996)}tail` : undefined)
|
|
messages = applyCursorFrame(messages, sessionId, frame({ sessionUpdate: 'tool_call_update', toolCallId: 'bash', _meta: { terminal_exit: { exit_code: exitCode } } }))
|
|
expect(messages[1]).toMatchObject({ state: backend === 'pi' ? exitCode === 0 ? 'finished' : 'failed' : 'running' })
|
|
if (backend === 'pi') {
|
|
messages = applyCursorFrame(messages, sessionId, frame({ sessionUpdate: 'tool_call_update', toolCallId: 'bash', status: 'completed' }))
|
|
// A later generic completion must not erase terminal failure or output.
|
|
expect(messages[1]).toMatchObject({ state: exitCode === 0 ? 'finished' : 'failed', resultDetail: { text: tool.resultDetail?.text } })
|
|
}
|
|
} }))))
|
|
})
|
|
|
|
it('uses PI-only file and terminal scope instead of Harness or another ACP backend', async () => {
|
|
const workspaceToolCall = vi.fn(async () => ({}))
|
|
const openStream = vi.fn(async () => ({ streamId: 'tools', close: async () => undefined }))
|
|
const tools = new AcpSessionTools({ workspaceToolCall, openStream } as unknown as AgentAcpClient, 'pi')
|
|
await tools.listFiles('pi:native', '.', undefined)
|
|
expect(workspaceToolCall).toHaveBeenCalledWith('native', 'pi', 'workspaceFiles/list', { workspaceFileScopeId: 'pi:native', path: '.' }, undefined)
|
|
await tools.createTerminal('pi:native', 'terminal', 80, 24)
|
|
expect(workspaceToolCall).toHaveBeenCalledWith('native', 'pi', 'terminal/create', { agentId: 'pi:native', request: { id: 'terminal', cols: 80, rows: 24 } }, undefined)
|
|
const signal = new AbortController().signal
|
|
const stream = await tools.followTerminal('pi:native', 'terminal', 'attachment', signal)
|
|
expect(openStream).toHaveBeenCalledWith('native', expect.any(Function), expect.any(Function), signal,
|
|
{ backend: 'pi', endpoint: 'terminal/follow', args: { sessionId: 'pi:native', id: 'terminal', attachmentId: 'attachment' } })
|
|
await stream.close()
|
|
})
|
|
|
|
it('scopes model and thinking changes to PI and reads the authoritative selection after commit', async () => {
|
|
const models = { current: { provider: 'pi', model: 'provider/model', reasoningEffort: 'high' }, routable: true,
|
|
groups: [{ id: 'pi', name: 'PI', models: [{ id: 'provider/model', name: 'Model', reasoning: { defaultEffort: 'high', efforts: [{ id: 'high', name: 'High' }] } }] }] }
|
|
const sessionModels = vi.fn(async () => models)
|
|
const selectModel = vi.fn(async () => models.current)
|
|
const client = { sessionModels, selectModel } as unknown as AgentAcpClient
|
|
const result = await selectPiModel(client, 'durable', { provider: 'pi', model: 'provider/model', reasoningEffort: 'high' })
|
|
expect(selectModel).toHaveBeenCalledWith('durable', 'pi', { provider: 'pi', model: 'provider/model', reasoningEffort: 'high' })
|
|
expect(sessionModels).toHaveBeenCalledWith('durable', 'pi')
|
|
expect(selectModel.mock.invocationCallOrder[0]).toBeLessThan(sessionModels.mock.invocationCallOrder[0]!)
|
|
expect(result.current).toEqual(models.current)
|
|
expect(result.groups[0]?.models[0]?.reasoning).toEqual(models.groups[0]!.models[0]!.reasoning)
|
|
selectModel.mockClear()
|
|
sessionModels.mockClear()
|
|
await expect(selectPiModel(client, 'durable', { provider: 'codex', model: 'other' })).rejects.toThrow('Invalid ACP model provider')
|
|
expect(selectModel).not.toHaveBeenCalled()
|
|
selectModel.mockRejectedValueOnce(new Error('denied'))
|
|
await expect(selectPiModel(client, 'durable', { provider: 'pi', model: 'provider/model' })).rejects.toThrow('denied')
|
|
expect(selectModel).toHaveBeenCalledTimes(1)
|
|
expect(sessionModels).not.toHaveBeenCalled()
|
|
})
|
|
})
|