From 902adbf981c5fce4062dbc62862476cf7619646b Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:59:26 +0800 Subject: [PATCH] Import packages/plugin/tests/acp-virtual-harness.test.ts --- .../plugin/tests/acp-virtual-harness.test.ts | 1210 +++++++++++++++++ 1 file changed, 1210 insertions(+) create mode 100644 packages/plugin/tests/acp-virtual-harness.test.ts diff --git a/packages/plugin/tests/acp-virtual-harness.test.ts b/packages/plugin/tests/acp-virtual-harness.test.ts new file mode 100644 index 0000000..deaff3e --- /dev/null +++ b/packages/plugin/tests/acp-virtual-harness.test.ts @@ -0,0 +1,1210 @@ +import { runScenarios } from '../../../scripts/test-scenarios.mjs' +import { describe, expect, it, vi } from 'vitest' +import { + AcpVirtualHarness, + discoverAcpVirtualWorkspaces, + acpCwdWorkspaceId, + type AcpClientLike, +} from '../src/acp/virtual-harness.js' +import { AcpSessionHistoryCache } from '../src/session-history-cache.js' +import type { AcpSessionArchivedData, AgentAcpFrameData } from '@dsh-remote/protocol' + +type AgentAcpClientLike = AcpClientLike + +function fakeAcp() { + return { + createSession: vi.fn(async (cwd: string) => ({ sessionId: 'acp_1', cwd })), + listSessions: vi.fn(async () => [{ conversationId: 'remote-history', title: 'Remote history', createdAt: 1, updatedAt: 2 }]), + prompt: vi.fn(async () => ({})), + cancel: vi.fn(async () => ({})), + listDirectory: vi.fn(async (path: string) => ({ + path, + home: path, + crumbs: [{ name: 'repo', path, hidden: false }], + entries: [], + truncated: false, + })), + openStream: vi.fn(async () => ({ close: async () => undefined })), + respond: vi.fn(async () => ({})), + } +} + +describe('AcpVirtualHarness', () => { + it('recovers delayed ACP titles without stale catalog reads replacing newer metadata', async () => { + await runScenarios(['delayed catalog', 'live rename', 'workspace refresh', 'manual rename', 'closed projection', 'retry exhausted', 'read timeout'].map(name => ({ name, run: async () => { + vi.useFakeTimers() + const catalog = (title: string) => [{ conversationId: 'remote-history', title, createdAt: 1, updatedAt: 2 }] + const placeholder = 'New session - 2026-10-18T14:29:07.000Z' + let onFrame!: (frame: AgentAcpFrameData) => void + let resolveRead!: (items: ReturnType) => void + let readSignal: AbortSignal | undefined + const listSessions = vi.fn(async (_path: string, _backend?: string, _limit?: number, _signal?: AbortSignal) => catalog('Native title')) + .mockResolvedValueOnce(catalog(placeholder)) + .mockImplementationOnce((_path, _backend, _limit, signal) => { + readSignal = signal + return new Promise(resolve => { resolveRead = resolve }) + }) + const client = { ...fakeAcp(), listSessions, + openStream: vi.fn(async (_id: string, handler: typeof onFrame) => { onFrame = handler; return { close: async () => undefined } }), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') + const signal = new AbortController().signal + const request = { sessionId: 'opencode:remote-history' } + const emit = (update: Record) => onFrame({ frame: { method: 'session/update', params: { sessionId: 'remote-history', update } } } as AgentAcpFrameData) + const projection = () => target.dispatch('session/projections', { args: { request } }, signal) + try { + await target.selectOrCreateWorkspace('/test') + await target.dispatch('session/prompt', { args: { request: { ...request, content: [{ type: 'text', text: 'First request' }] } } }, signal) + const rediscovery = name === 'workspace refresh' ? target.dispatch('session/list', { args: {} }, signal) : undefined + if (!rediscovery) emit({ sessionUpdate: 'prompt_completed' }) + expect(await projection()).toMatchObject({ ok: true, value: { values: { title: 'First request' } } }) + expect(listSessions).toHaveBeenCalledTimes(2) + if (name === 'live rename' || name === 'workspace refresh') emit({ sessionUpdate: 'session_info_update', title: 'Live title' }) + if (name === 'manual rename') await target.dispatch('session/rename', { args: { request: { ...request, title: 'Manual title' } } }, signal) + if (name === 'closed projection') { + await target.close() + expect(readSignal?.aborted).toBe(true) + } + if (name === 'retry exhausted') listSessions.mockResolvedValue(catalog(placeholder)) + if (name !== 'read timeout') resolveRead(catalog(name === 'delayed catalog' || name === 'retry exhausted' ? placeholder : 'Stale title')) + await rediscovery + await vi.advanceTimersByTimeAsync(20_000) + if (name === 'read timeout') { + expect(readSignal?.aborted).toBe(true) + resolveRead(catalog('Late title')) + await vi.advanceTimersByTimeAsync(0) + } + if (name !== 'closed projection') { + const title = name === 'live rename' || name === 'workspace refresh' ? 'Live title' : name === 'manual rename' ? 'Manual title' + : name === 'retry exhausted' || name === 'read timeout' ? 'First request' : 'Native title' + expect(await projection()).toMatchObject({ ok: true, value: { values: { title } } }) + } + expect(listSessions).toHaveBeenCalledTimes(name === 'delayed catalog' ? 3 : name === 'retry exhausted' ? 6 : 2) + expect(vi.getTimerCount()).toBe(0) + } finally { await target.close(); vi.useRealTimers() } + } }))) + }) + + it('restores OpenCode title metadata from history and accepts only its own live updates', async () => { + await runScenarios(['New session - 2026-10-18T14:29:07.000Z', 'Native title'].map(title => ({ name: title, run: async () => { + const client = { ...fakeAcp(), + listSessions: vi.fn(async () => [{ conversationId: 'remote-history', title, createdAt: 1, updatedAt: 2 }]), + loadSessionHistory: vi.fn(async () => ['Original request', 'Later request'].map((text, seq) => ({ type: 'event', event: { + type: 'user/message', seq, time: 0, data: { content: [{ type: 'text', text }] }, + } }))), + openStream: vi.fn(async (_id: string, handler: (frame: AgentAcpFrameData) => void) => { onFrame = handler; return { close: async () => undefined } }), + } + let onFrame!: (frame: AgentAcpFrameData) => void + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') + const controller = new AbortController() + const request = { sessionId: 'opencode:remote-history' } + const projection = () => target.dispatch('session/projections', { args: { request } }, controller.signal) + let iterator: AsyncIterator | undefined + try { + await target.selectOrCreateWorkspace('/test') + const stream = await target.open('session/follow', { args: { request } }, controller.signal) + iterator = stream[Symbol.asyncIterator]() + const expected = title === 'Native title' ? title : 'Original request' + expect((await iterator.next()).value).toMatchObject({ type: 'snapshot', projections: { values: { title: expected } } }) + // A stale placeholder catalog cannot overwrite the recovered title. + await target.dispatch('session/list', { args: {} }, controller.signal) + expect(await projection()).toMatchObject({ ok: true, value: { values: { title: expected } } }) + for (const [sessionId, update] of [ + ['other', { sessionUpdate: 'session_info_update', title: 'Other session' }], + ['remote-history', { sessionUpdate: 'session_info_update', _meta: { retry: true } }], + ] as const) onFrame({ frame: { method: 'session/update', params: { sessionId, update } } } as AgentAcpFrameData) + expect(await projection()).toMatchObject({ ok: true, value: { values: { title: expected } } }) + onFrame({ frame: { method: 'session/update', params: { sessionId: 'remote-history', update: { sessionUpdate: 'session_info_update', title: 'Confirmed title' } } } } as AgentAcpFrameData) + expect(await projection()).toMatchObject({ ok: true, value: { values: { title: 'Confirmed title' } } }) + } finally { controller.abort(); await iterator?.return?.(); await target.close() } + } }))) + }) + + it('requires exact registered session identities for model reads and changes', async () => { + await runScenarios([ + { id: 'opencode:remote-history', nativeId: 'remote-history' }, + { id: 'other-history', nativeId: 'other-history' }, + { id: 'history' }, + { id: 'opencode:missing' }, + { id: 'claude:remote-history' }, + ].map(scenario => ({ name: scenario.id, run: async () => { + const current = { provider: 'opencode', model: 'host/a' } + const selected = { provider: 'opencode', model: 'host/b' } + const client = { ...fakeAcp(), + listSessions: vi.fn(async () => ['remote-history', 'other-history'].map(conversationId => ({ conversationId, title: conversationId, createdAt: 1, updatedAt: 2 }))), + sessionModels: vi.fn(async () => ({ current, routable: true, failures: [], + groups: [{ id: 'opencode', name: 'OpenCode', models: [{ id: 'host/a', name: 'A' }, { id: 'host/b', name: 'B' }] }] })), + selectModel: vi.fn(async () => selected), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') + const signal = new AbortController().signal + try { + await target.selectOrCreateWorkspace('/test') + const request = { sessionId: scenario.id, ...selected } + const models = await target.dispatch('session/models', { args: { request } }, signal) + const selection = await target.dispatch('session/selectModel', { args: { request } }, signal) + if (scenario.nativeId) { + expect(models).toMatchObject({ ok: true, value: { current } }) + expect(selection).toMatchObject({ ok: true, value: { selected } }) + expect(client.sessionModels).toHaveBeenCalledWith(scenario.nativeId, 'opencode') + expect(client.selectModel).toHaveBeenCalledTimes(1) + expect(client.selectModel).toHaveBeenCalledWith(scenario.nativeId, 'opencode', selected) + } else { + expect(models).toMatchObject({ ok: false, error: { code: 'session-not-found' } }) + expect(selection).toMatchObject({ ok: false, error: { code: 'session-not-found' } }) + expect(client.sessionModels).not.toHaveBeenCalled() + expect(client.selectModel).not.toHaveBeenCalled() + } + } finally { await target.close() } + } }))) + }) + + it('prefers exact model IDs and rejects ambiguous aliases before upstream mutation', async () => { + await runScenarios([ + { model: 'openrouter/anthropic/sonnet', expected: 'openrouter/anthropic/sonnet' }, + { model: 'anthropic/sonnet', expected: 'anthropic/sonnet' }, + { model: 'haiku', expected: 'vendor/haiku' }, + { model: 'router/vendor/haiku', expected: 'vendor/haiku' }, + { model: 'sonnet' }, + { model: 'router/openrouter/anthropic/sonnet' }, + { model: 'missing' }, + ].map(scenario => ({ name: scenario.model, run: async () => { + const client = { ...fakeAcp(), + sessionModels: vi.fn(async () => ({ current: { provider: 'opencode', model: 'anthropic/sonnet' }, routable: true, failures: [], + groups: [{ id: 'opencode', name: 'OpenCode', models: ['anthropic/sonnet', 'openrouter/anthropic/sonnet', 'vendor/haiku'].map(id => ({ id, name: id })) }] })), + selectModel: vi.fn(async (_id: string, _backend: string, selection: { provider: string; model: string }) => selection), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + const request = { sessionId: workspace.sessionIds[0]!, provider: 'opencode', model: scenario.model } + const result = await target.dispatch('session/selectModel', { args: { request } }, signal) + if (scenario.expected) { + const selected = { provider: 'opencode', model: scenario.expected } + expect(result).toMatchObject({ ok: true, value: { selected } }) + expect(client.selectModel).toHaveBeenCalledTimes(1) + expect(client.selectModel).toHaveBeenCalledWith('remote-history', 'opencode', selected) + expect(await target.dispatch('session/projections', { args: { request } }, signal)).toMatchObject({ ok: true, + value: { values: { modelSelection: { next: selected } } } }) + } else { + expect(result).toMatchObject({ ok: false, error: { code: 'model-unavailable' } }) + expect(client.selectModel).not.toHaveBeenCalled() + } + } finally { await target.close() } + } }))) + }) + + it('preserves authoritative history failures and permits recovery after retry', async () => { + await runScenarios((['pi', 'claude', 'opencode'] as const).map(backend => ({ name: backend, run: async () => { + const client = { ...fakeAcp(), loadSessionHistory: vi.fn(async () => [] as unknown[]) } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend) + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + const request = { sessionId: workspace.sessionIds[0]! } + for (const endpoint of ['session/history', 'session/page']) { + client.loadSessionHistory.mockRejectedValueOnce(Object.assign(new Error('History reader is busy'), { code: 'ACP_HISTORY_BUSY' })) + expect(await target.dispatch(endpoint, { args: { request } }, signal)).toMatchObject({ ok: false, error: { code: 'ACP_HISTORY_BUSY' } }) + expect(await target.dispatch(endpoint, { args: { request } }, signal)).toMatchObject({ ok: true, value: { records: [] } }) + } + const events = [{ type: 'event', event: { type: 'user/message', seq: 0, time: 1, data: { content: [{ type: 'text', text: 'Saved prompt' }] } } }] + client.loadSessionHistory.mockResolvedValueOnce(events) + expect(await target.dispatch('session/history', { args: { request } }, signal)).toMatchObject({ ok: true, value: { records: events } }) + } finally { await target.close() } + } }))) + }) + + it('deduplicates concurrent ACP history hydration across backends and reuses cached history across workspace switches', async () => { + await runScenarios((['claude', 'hermes', 'opencode', 'pi'] as const).map(backend => ({ name: backend, run: async () => { + const event = { type: 'event', event: { type: 'user/message', seq: 0, time: 1, data: { content: [{ type: 'text', text: 'Cached project prompt' }] } } } + let resolveHistory!: (value: unknown[]) => void + const client = { + ...fakeAcp(), + listSessions: vi.fn(async () => [{ conversationId: 's1', cwd: '/repo-a', title: 'Repo A', createdAt: 10, updatedAt: 20 }]), + loadSessionHistory: vi.fn(() => new Promise(resolve => { resolveHistory = resolve })), + } + const cache = new AcpSessionHistoryCache() + const signal = new AbortController().signal + const first = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend, undefined, cache) + try { + const workspace = await first.selectWorkspace(`${backend}:cwd:/repo-a`) + const request = { sessionId: workspace.sessionIds[0]!, address: { sessionId: workspace.sessionIds[0]! } } + const projections = first.dispatch('session/projections', { args: { request } }, signal) + const history = first.dispatch('session/history', { args: { request } }, signal) + const page = first.dispatch('session/page', { args: { request } }, signal) + expect(client.loadSessionHistory).toHaveBeenCalledTimes(1) + resolveHistory([event]) + await expect(projections).resolves.toMatchObject({ ok: true }) + await expect(history).resolves.toMatchObject({ ok: true, value: { records: [event] } }) + await expect(page).resolves.toMatchObject({ ok: true, value: { records: [event] } }) + expect(first.openedSessionId).toBe(workspace.sessionIds[0]!) + } finally { + await first.close() + } + + const second = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend, undefined, cache) + try { + const workspace = await second.selectWorkspace(`${backend}:cwd:/repo-a`) + const request = { sessionId: workspace.sessionIds[0]!, address: { sessionId: workspace.sessionIds[0]! } } + await expect(second.dispatch('session/history', { args: { request } }, signal)).resolves.toMatchObject({ + ok: true, + value: { records: [event] }, + }) + expect(client.loadSessionHistory).toHaveBeenCalledTimes(1) + } finally { + await second.close() + } + } }))) + }) + + it('commits ACP model projections only after Host confirmation and fails closed on discovery errors', async () => { + await runScenarios((['cursor', 'claude', 'pi', 'opencode', 'antigravity'] as const).map(backend => ({ name: backend, run: async () => { + const current = { provider: backend, model: 'host/a' } + const client = { ...fakeAcp(), + sessionModels: vi.fn(async () => ({ current, routable: true, failures: [], + groups: [{ id: backend, name: backend, models: [{ id: 'host/a', name: 'A' }, { id: 'host/b', name: 'B' }] }] })), + selectModel: vi.fn(async () => { throw new Error('upstream rejected') }), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend) + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + const sessionId = workspace.sessionIds[0]! + const request = { sessionId, provider: backend, model: 'host/b' } + expect(await target.dispatch('session/models', { args: { request } }, signal)).toMatchObject({ ok: true, value: { current } }) + expect(await target.dispatch('session/selectModel', { args: { request } }, signal)).toMatchObject({ ok: false }) + expect(client.selectModel).toHaveBeenCalledWith(backend === 'cursor' ? 'acp_1' : 'remote-history', backend, { provider: backend, model: 'host/b' }) + expect(await target.dispatch('session/projections', { args: { request } }, signal)).toMatchObject({ ok: true, + value: { values: { modelSelection: { next: current } } } }) + client.sessionModels.mockRejectedValueOnce(new Error('catalog failed')) + expect(await target.dispatch('session/models', { args: { request } }, signal)).toMatchObject({ ok: false }) + } finally { await target.close() } + } }))) + }) + + it('requires native archive confirmation, retains history and applies shared catalog events', async () => { + let notify!: (data: AcpSessionArchivedData) => void + const unsubscribe = vi.fn() + const client = { ...fakeAcp(), supportsArchive: () => true, + archiveSession: vi.fn(async () => { throw new Error('native rejected') }), + onSessionArchived: (handler: typeof notify) => { notify = handler; return unsubscribe }, + loadSessionHistory: vi.fn(async () => []), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + const sessionId = workspace.sessionIds[0]! + const invoke = (endpoint: string) => target.dispatch(endpoint, { args: { request: { sessionId } } }, signal) + expect(await invoke('workspace/archiveSession')).toMatchObject({ ok: false }) + expect(workspace.sessionIds).toContain(sessionId) + client.archiveSession.mockImplementationOnce(async () => undefined as never) + expect(await invoke('workspace/archiveSession')).toMatchObject({ ok: true, value: { archivedSessionIds: [sessionId] } }) + expect(client.archiveSession).toHaveBeenLastCalledWith('remote-history', 'opencode') + expect(await invoke('session/history')).toMatchObject({ ok: true }) + notify({ backend: 'opencode', sessionId: 'other', archived: true }) + expect(await target.dispatch('workspace/list', { args: {} }, signal)).toMatchObject({ ok: true, + value: { archivedSessionIds: [sessionId, 'opencode:other'] } }) + } finally { await target.close() } + expect(unsubscribe).toHaveBeenCalledOnce() + }) + + it('keeps a new AGY follow empty and reuses only the requested blank session', async () => { + const client = { ...fakeAcp(), + listSessions: vi.fn(async () => [{ conversationId: 'old', title: 'Old history', createdAt: 1, updatedAt: 2 }]), + loadSessionHistory: vi.fn(async () => [{ type: 'event', event: { type: 'user/message', seq: 0, time: 1, data: {} } }]), + } + client.createSession.mockResolvedValue({ sessionId: 'new', cwd: '/test' }) + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'antigravity') + const workspace = await target.selectOrCreateWorkspace('/test') + const signal = new AbortController().signal + const created = await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal) + expect(created).toMatchObject({ ok: true, value: { sessionId: 'acp:new' } }) + const stream = await target.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'acp:new' } } } }, signal) + const iterator = stream[Symbol.asyncIterator]() + expect((await iterator.next()).value).toMatchObject({ type: 'snapshot', header: { id: 'acp:new' }, records: [], cursor: -1 }) + await expect(target.dispatch('session/projections', { args: { request: { sessionId: 'acp:new' } } }, signal)) + .resolves.toMatchObject({ ok: true, value: { kind: 'sequenced', asOfSeq: -1 } }) + expect(client.loadSessionHistory).not.toHaveBeenCalled() + const calls = client.createSession.mock.calls.length + expect(await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId, sessionId: 'acp:new' } } }, signal)) + .toMatchObject({ ok: true, value: { sessionId: 'acp:new' } }) + expect(client.createSession.mock.calls).toHaveLength(calls) + expect(await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal)) + .toMatchObject({ ok: false, error: { code: 'session-already-exists' } }) + await iterator.return?.() + await target.close() + }) + + it('passes AGY images and exposes attachments only in their own Session', async () => { + const data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/l9sAAAAASUVORK5CYII=' + let onFrame: ((frame: AgentAcpFrameData) => void) | undefined + const client = { ...fakeAcp(), listSessions: vi.fn(async () => [{ conversationId: 'old', title: 'Old', createdAt: 1, updatedAt: 2 }]), + openStream: vi.fn(async (_id: string, handler: (frame: AgentAcpFrameData) => void) => { onFrame = handler; return { close: async () => undefined } }), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'antigravity') + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal) + expect(await target.dispatch('session/prompt', { args: { request: { sessionId: 'acp:acp_1', content: [{ type: 'image', mediaType: 'image/png', data }] } } }, signal)).toMatchObject({ ok: true }) + expect(client.prompt).toHaveBeenCalledWith('acp_1', '', signal, [{ type: 'image', mimeType: 'image/png', data }], 'antigravity') + const history = await target.dispatch('session/history', { args: { request: { sessionId: 'acp:acp_1' } } }, signal) as any + const image = history.value.records.find((entry: any) => entry.event.type === 'user/message').event.data.content[0] + expect(image).toMatchObject({ type: 'image', attachment: { mediaType: 'image/png', width: 1, height: 1 } }) + expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'acp:acp_1', attachmentId: image.attachment.attachmentId } } }, signal)).toMatchObject({ ok: true, value: { data } }) + // 0.2.2 clients send the full image reference instead of the bare id. + expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'acp:acp_1', attachment: image.attachment } } }, signal)).toMatchObject({ ok: true, value: { data } }) + expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'acp:old', attachmentId: image.attachment.attachmentId } } }, signal)).toMatchObject({ ok: false }) + onFrame!({ frame: { method: 'session/update', params: { sessionId: 'acp_1', update: { sessionUpdate: 'prompt_completed' } } } } as AgentAcpFrameData) + } finally { await target.close() } + }) + + it('passes images and exposes attachments in Hermes sessions', async () => { + const data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/l9sAAAAASUVORK5CYII=' + let onFrame: ((frame: AgentAcpFrameData) => void) | undefined + const client = { + ...fakeAcp(), + call: vi.fn(async (method: string) => method === 'session/new' ? { sessionId: 'hermes_1' } : {}), + prompt: vi.fn(async () => ({})), + openStream: vi.fn(async (_id: string, handler: (frame: AgentAcpFrameData) => void) => { onFrame = handler; return { close: async () => undefined } }), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'hermes') + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal) + expect(await target.dispatch('session/prompt', { args: { request: { sessionId: 'hermes:hermes_1', content: [{ type: 'image', mediaType: 'image/png', data }] } } }, signal)).toMatchObject({ ok: true }) + expect(client.prompt).toHaveBeenCalledWith('hermes_1', '', signal, [{ type: 'image', mimeType: 'image/png', data }], 'hermes') + const history = await target.dispatch('session/history', { args: { request: { sessionId: 'hermes:hermes_1' } } }, signal) as any + const image = history.value.records.find((entry: any) => entry.event.type === 'user/message').event.data.content[0] + expect(image).toMatchObject({ type: 'image', attachment: { mediaType: 'image/png', width: 1, height: 1 } }) + expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'hermes:hermes_1', attachmentId: image.attachment.attachmentId } } }, signal)).toMatchObject({ ok: true, value: { data } }) + onFrame!({ frame: { method: 'session/update', params: { sessionId: 'hermes_1', update: { sessionUpdate: 'prompt_completed' } } } } as AgentAcpFrameData) + } finally { await target.close() } + }) + + it('delegates unprojected global surfaces to the Host gateway', async () => { + const hostCarrier = { + invoke: vi.fn(async () => undefined), + dispatch: vi.fn(async (endpoint: string) => ({ ok: true as const, value: { endpoint } })), + open: vi.fn(async () => (async function* () { yield { type: 'ready' } })()), + } + const target = new AcpVirtualHarness(fakeAcp(), { deviceId: 'host-1', name: 'Host' }, 'antigravity', hostCarrier) + const signal = new AbortController().signal + await expect(target.dispatch('settings/describe', { args: {} }, signal)) + .resolves.toEqual({ ok: true, value: { endpoint: 'settings/describe' } }) + expect(hostCarrier.dispatch).toHaveBeenCalledWith('settings/describe', { args: {} }, signal) + const stream = await target.open('account/watch', { args: {} }, signal) + await expect(stream[Symbol.asyncIterator]().next()).resolves.toEqual({ done: false, value: { type: 'ready' } }) + expect(hostCarrier.open).toHaveBeenCalledWith('account/watch', { args: {} }, signal) + await target.close() + }) + + it('provides the required native carrier stream baselines', async () => { + await runScenarios([ + { + name: 'opens the Session control stream with the required baseline', + run: async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) + const stream = await target.open('session/control', {}, new AbortController().signal) + const first = await stream[Symbol.asyncIterator]().next() + expect(first.value).toEqual({ type: 'baseline', value: { projections: {} } }) + await target.close() + }, + }, + { + name: 'opens the Workspace follow stream with the complete 0.2 baseline', + run: async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) + await target.selectOrCreateWorkspace('/workspace/repo') + const stream = await target.open('workspace/follow', {}, new AbortController().signal) + const first = await stream[Symbol.asyncIterator]().next() + expect(first.value).toMatchObject({ + type: 'baseline', + value: { archivedSessionIds: [], pinnedSessionIds: [] }, + }) + await target.close() + }, + }, + { + name: 'opens the event stream with the required ready frame', + run: async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) + await target.selectOrCreateWorkspace('/workspace/repo') + const stream = await target.open('$events', {}, new AbortController().signal) + const first = await stream[Symbol.asyncIterator]().next() + expect(first.value).toMatchObject({ type: 'ready', host: { home: '/workspace/repo' } }) + await target.close() + }, + }, + { + name: 'answers the background-job roster without a terminal stream failure', + run: async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') + const rosterController = new AbortController() + const roster = await target.open('job/list', { args: { request: { sessionId: 'acp:job' } } }, rosterController.signal) + const rosterIterator = roster[Symbol.asyncIterator]() + await expect(rosterIterator.next()).resolves.toEqual({ done: false, value: { type: 'rows', jobs: [] } }) + rosterController.abort() + await expect(rosterIterator.next()).resolves.toMatchObject({ done: true }) + + const followController = new AbortController() + const follow = await target.open('job/follow', { args: { request: { jobId: 'job-1' } } }, followController.signal) + followController.abort() + await expect(follow[Symbol.asyncIterator]().next()).resolves.toMatchObject({ done: true }) + await target.close() + }, + }, + { + name: 'emits opening snapshot with assistantStream baseline in session/follow', + run: async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') + await target.selectOrCreateWorkspace('/workspace/repo') + const created = (await target.dispatch( + 'session/create', + { + args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity') } }, + }, + new AbortController().signal, + )) as { ok: true; value: { sessionId: string } } + + const controller = new AbortController() + const source = await target.open( + 'session/follow', + { + args: { + request: { + address: { kind: 'session', sessionId: created.value.sessionId }, + assistantStream: true, + }, + }, + }, + controller.signal, + ) + const iterator = source[Symbol.asyncIterator]() + const snapshot = await iterator.next() + expect(snapshot.value).toMatchObject({ + type: 'snapshot', + header: { version: 3, id: created.value.sessionId }, + assistantStream: { revision: 0 }, + }) + controller.abort() + await iterator.return?.() + await target.close() + }, + }, + ]) + }, 20000) + + it('forwards text prompts to Agent ACP', async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) + await target.selectOrCreateWorkspace('/workspace/repo') + await target.dispatch('session/create', { + args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'cursor') } }, + }, new AbortController().signal) + + const prompted = await target.dispatch('session/prompt', { + args: { request: { + sessionId: 'cursor:acp_1', + content: [{ type: 'text', text: 'List files' }], + } }, + }, new AbortController().signal) + expect(prompted.ok).toBe(true) + expect(client.prompt).toHaveBeenCalledWith('acp_1', 'List files', expect.any(AbortSignal), [], 'cursor') + expect(client.openStream).toHaveBeenCalled() + await target.close() + }) + + it('maps Typert approval outcomes to ACP respond decisions', async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) + await target.selectOrCreateWorkspace('/workspace/repo') + await target.dispatch('session/create', { + args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'cursor') } }, + }, new AbortController().signal) + + // Seed a pending approval the same way stream frames would. + ;(target as unknown as { pendingApprovals: Map }) + .pendingApprovals.set('req_1', { requestHandle: 'req_1', sessionId: 'cursor:acp_1' }) + + await expect(target.dispatch('$events/result', { args: { eventId: 'req_1', outcome: { kind: 'result', value: 'allowed-once' } } }, new AbortController().signal)).resolves.toMatchObject({ ok: true }) + expect(client.respond).toHaveBeenCalledWith('req_1', 'allow-once', undefined, expect.any(AbortSignal)) + await target.close() + }) + + it('loads and pages history only through the remote ACP authority', async () => { + await runScenarios([ + { + name: 'loads session/page with address object from DSH session controller', + run: async () => { + const client = fakeAcp() + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') + await target.selectOrCreateWorkspace('/workspace/repo') + const created = (await target.dispatch( + 'session/create', + { + args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity') } }, + }, + new AbortController().signal, + )) as { ok: true; value: { sessionId: string } } + const sessionId = created.value.sessionId + + // DSH SessionController sends address instead of sessionId: + const pageResult = (await target.dispatch( + 'session/page', + { + args: { + request: { + address: { kind: 'session', sessionId }, + throughSeq: 0, + }, + }, + }, + new AbortController().signal, + )) as { ok: true; value: { records: unknown[]; hasMore: boolean } } + + expect(pageResult.ok).toBe(true) + expect(pageResult.value.records).toEqual([]) + expect(pageResult.value.hasMore).toBe(false) + + // Send a prompt to create history events and verify follow snapshot cursor matches tail record seq + await target.dispatch( + 'session/prompt', + { + args: { + request: { + sessionId, + content: [{ type: 'text', text: 'Hello Antigravity' }], + }, + }, + }, + new AbortController().signal, + ) + + const followStream = await target.open( + 'session/follow', + { + args: { + request: { + address: { kind: 'session', sessionId }, + assistantStream: true, + }, + }, + }, + new AbortController().signal, + ) + + const iterator = followStream[Symbol.asyncIterator]() + const snapshotFrame = await iterator.next() + expect(snapshotFrame.done).toBe(false) + const snapshot = snapshotFrame.value as { + type: string + cursor: number + records: Array<{ event: { seq: number } }> + } + expect(snapshot.type).toBe('snapshot') + expect(snapshot.records.length).toBeGreaterThan(0) + // The cursor MUST equal the tail entry's seq (assertPageThrough requirement) + expect(snapshot.cursor).toBe(snapshot.records.at(-1)!.event.seq) + + // And session/page throughSeq returns records up to that seq + const pageWithThrough = (await target.dispatch( + 'session/page', + { + args: { + request: { + address: { kind: 'session', sessionId }, + throughSeq: 0, + }, + }, + }, + new AbortController().signal, + )) as { ok: true; value: { records: Array<{ event: { seq: number } }> } } + expect(pageWithThrough.ok).toBe(true) + expect(pageWithThrough.value.records.at(-1)!.event.seq).toBe(0) + + await target.close() + }, + }, + { + name: 'uses only the remote ACP history, including empty or unavailable history', + run: async () => { + const client = { + ...fakeAcp(), + listSessions: vi.fn(async () => [ + { conversationId: 'remote-only', title: 'Remote', createdAt: 1, updatedAt: 2 }, + ]), + loadSessionHistory: vi.fn(async () => [] as unknown[]), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'antigravity') + try { + await target.selectOrCreateWorkspace('/workspace/repo') + const history = () => + target.dispatch( + 'session/history', + { args: { sessionId: 'acp:remote-only' } }, + new AbortController().signal, + ) + expect(await history()).toMatchObject({ ok: true, value: { records: [] } }) + client.loadSessionHistory.mockRejectedValueOnce(new Error('remote unavailable')) + expect(await history()).toMatchObject({ ok: true, value: { records: [] } }) + expect(client.loadSessionHistory).toHaveBeenCalledWith('acp:remote-only', 'antigravity') + } finally { + await target.close() + } + }, + }, + { + name: 'hydrates session history via client.loadSessionHistory RPC when available', + run: async () => { + const mockEvents = [ + { type: 'event', event: { type: 'turn/start', seq: 0, time: 1000, data: { turn: 1 } } }, + { type: 'event', event: { type: 'step/start', seq: 1, time: 1000, data: { turn: 1, step: 1 } } }, + { + type: 'event', + event: { + type: 'user/message', + seq: 2, + time: 1000, + data: { role: 'user', content: [{ type: 'text', text: 'hello' }] }, + surfaceOp: 'append', + }, + }, + { + type: 'event', + event: { + type: 'assistant/message', + seq: 3, + time: 1001, + data: { role: 'assistant', message: { content: [{ type: 'text', text: 'hi' }] } }, + surfaceOp: 'append', + }, + }, + { type: 'event', event: { type: 'step/end', seq: 4, time: 1001, data: { turn: 1, step: 1 } } }, + { type: 'event', event: { type: 'turn/end', seq: 5, time: 1001, data: { turn: 1 } } }, + ] + const client: AcpClientLike = { + createSession: vi.fn(async () => ({ sessionId: 'new-session' })), + prompt: vi.fn(async () => {}), + cancel: vi.fn(async () => {}), + listDirectory: vi.fn(async () => []), + openStream: vi.fn(async () => ({ close: async () => {} })), + respond: vi.fn(async () => {}), + listSessions: vi.fn(async () => [ + { + conversationId: 'remote-conv-1', + title: 'Remote conversation', + createdAt: 1000, + updatedAt: 2000, + }, + ]), + loadSessionHistory: vi.fn(async () => mockEvents), + } + + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') + const workspaceId = acpCwdWorkspaceId('/var/lib/dsh/workspace/ds-harness-remote', 'antigravity') + const ws = await target.selectWorkspace(workspaceId) + expect(client.listSessions).toHaveBeenCalled() + expect(ws.sessionIds).toContain('acp:remote-conv-1') + + const historyRes = await target.dispatch( + 'session/history', + { + args: { sessionId: 'acp:remote-conv-1', maxMessages: 50 }, + }, + new AbortController().signal, + ) + + expect(client.loadSessionHistory).toHaveBeenCalledWith('acp:remote-conv-1', 'antigravity') + expect(historyRes.ok).toBe(true) + if (historyRes.ok) { + const records = (historyRes.value as any).records + expect(records.length).toBe(6) + const types = records.map((r: any) => r.event.type) + expect(types).toContain('user/message') + expect(types).toContain('assistant/message') + } + await target.close() + }, + }, + ]) + }, 15000) + + it('projects ordered ACP assistant and user turns into native events', async () => { + await runScenarios([ + { + name: 'streams assistant response via assistant-stream frames and commits assistant/message event', + run: async () => { + let inboundHandler: ((frame: { frame: { method: string; params: unknown } }) => void) | undefined + const client = { + ...fakeAcp(), + openStream: vi.fn(async (_sessionId: string, onFrame: (frame: unknown) => void) => { + inboundHandler = onFrame as never + return { close: vi.fn(async () => undefined) } + }), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') + await target.selectOrCreateWorkspace('/workspace/repo') + const created = (await target.dispatch( + 'session/create', + { + args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity') } }, + }, + new AbortController().signal, + )) as { ok: true; value: { sessionId: string } } + const sessionId = created.value.sessionId + + const followController = new AbortController() + const followStream = await target.open( + 'session/follow', + { + args: { + request: { + address: { kind: 'session', sessionId }, + assistantStream: true, + }, + }, + }, + followController.signal, + ) + const iterator = followStream[Symbol.asyncIterator]() + const snapshot = await iterator.next() + expect(snapshot.value).toMatchObject({ type: 'snapshot' }) + + // Simulate ACP inbound events: agent_message_chunk -> prompt_completed + expect(inboundHandler).toBeDefined() + inboundHandler!({ + frame: { + method: 'session/update', + params: { + sessionId, + update: { + sessionUpdate: 'agent_message_chunk', + text: 'Hello, World!', + }, + }, + }, + }) + + // Should receive turn/start and step/start events before assistant-stream frames + const turnStart = await iterator.next() + expect(turnStart.value).toMatchObject({ type: 'event', event: { type: 'turn/start' } }) + + const stepStart = await iterator.next() + expect(stepStart.value).toMatchObject({ type: 'event', event: { type: 'step/start' } }) + + // Should receive assistant-stream start and chunk frames + const startFrame = await iterator.next() + expect(startFrame.value).toMatchObject({ + type: 'assistant-stream', + frame: { type: 'start', turn: 1 }, + }) + + const chunk1 = await iterator.next() + expect(chunk1.value).toMatchObject({ + type: 'assistant-stream', + frame: { type: 'chunk', chunk: { type: 'block-start', blockType: 'text' } }, + }) + + const chunk2 = await iterator.next() + expect(chunk2.value).toMatchObject({ + type: 'assistant-stream', + frame: { type: 'chunk', chunk: { type: 'text-delta', text: 'Hello, World!' } }, + }) + + // Now emit prompt_completed + inboundHandler!({ + frame: { + method: 'session/update', + params: { + sessionId, + update: { + sessionUpdate: 'prompt_completed', + stopReason: 'end_turn', + }, + }, + }, + }) + + // Should receive block-end, finish, assistant/message event, and end frame + const blockEnd = await iterator.next() + expect(blockEnd.value).toMatchObject({ + type: 'assistant-stream', + frame: { type: 'chunk', chunk: { type: 'block-end', block: { text: 'Hello, World!' } } }, + }) + + const finish = await iterator.next() + expect(finish.value).toMatchObject({ + type: 'assistant-stream', + frame: { type: 'chunk', chunk: { type: 'finish', reason: { kind: 'stop' } } }, + }) + + const msgEvent = await iterator.next() + expect(msgEvent.value).toMatchObject({ + type: 'event', + event: { + type: 'assistant/message', + surfaceOp: 'append', + data: { + message: { + role: 'assistant', + content: [{ type: 'text', text: 'Hello, World!' }], + }, + }, + }, + }) + + const endFrame = await iterator.next() + expect(endFrame.value).toMatchObject({ + type: 'assistant-stream', + frame: { + type: 'end', + outcome: { + kind: 'committed', + eventType: 'assistant/message', + }, + }, + }) + + // Verify session/page returns the committed assistant/message in history + const pageResult = (await target.dispatch( + 'session/page', + { + args: { + request: { + address: { kind: 'session', sessionId }, + cursor: -1, + }, + }, + }, + new AbortController().signal, + )) as { ok: true; value: { records: Array<{ event: { type: string; data: unknown } }> } } + expect(pageResult.ok).toBe(true) + const assistantRecord = pageResult.value.records.find((r) => r.event.type === 'assistant/message') + expect(assistantRecord).toBeDefined() + expect(assistantRecord?.event.data).toMatchObject({ + message: { + role: 'assistant', + content: [{ type: 'text', text: 'Hello, World!' }], + }, + stream: [ + { + type: 'chunk', + time: expect.any(Number), + chunk: { type: 'block-start', index: 0, blockType: 'text' }, + }, + { + type: 'chunk', + time: expect.any(Number), + chunk: { type: 'text-delta', index: 0, text: 'Hello, World!' }, + }, + { + type: 'chunk', + time: expect.any(Number), + chunk: { type: 'block-end', index: 0, block: { type: 'text', text: 'Hello, World!' } }, + }, + { type: 'chunk', time: expect.any(Number), chunk: { type: 'finish', reason: { kind: 'stop' } } }, + ], + }) + + followController.abort() + await iterator.return?.() + await target.close() + }, + }, + { + name: 'encloses user/message in turn/step and associates rpcId across multiple turns', + run: async () => { + let inboundHandler: ((frame: AgentAcpFrameData) => void) | undefined + const client: AgentAcpClientLike = { + createSession: vi.fn(async () => ({ sessionId: 'acp_multiturn' })), + prompt: vi.fn(async () => {}), + cancel: vi.fn(async () => {}), + listDirectory: vi.fn(async () => []), + openStream: vi.fn(async (_sid, onFrame) => { + inboundHandler = onFrame + return { close: async () => {} } + }), + respond: vi.fn(async () => {}), + } + + const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') + await target.selectOrCreateWorkspace('/workspace/repo') + const created = (await target.dispatch( + 'session/create', + { + args: { + request: { + workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity'), + sessionId: 'acp:acp_multiturn', + }, + }, + }, + new AbortController().signal, + )) as { ok: true; value: { sessionId: string } } + const sessionId = created.value.sessionId + + const followController = new AbortController() + const followStream = await target.open( + 'session/follow', + { + args: { + request: { + address: { kind: 'session', sessionId }, + assistantStream: true, + }, + }, + }, + followController.signal, + ) + const iterator = followStream[Symbol.asyncIterator]() + await iterator.next() // snapshot + + // Turn 1 prompt + await target.dispatch( + 'session/prompt', + { + args: { + request: { + sessionId, + requestId: 'req_turn_1', + content: [{ type: 'text', text: 'First question' }], + }, + }, + }, + new AbortController().signal, + ) + + // Should receive turn/start, step/start, user/message with rpcId + const t1TurnStart = await iterator.next() + expect(t1TurnStart.value).toMatchObject({ + type: 'event', + event: { type: 'turn/start', data: { turn: 1 } }, + }) + const t1StepStart = await iterator.next() + expect(t1StepStart.value).toMatchObject({ + type: 'event', + event: { type: 'step/start', data: { turn: 1, step: 1 } }, + }) + const t1UserMsg = await iterator.next() + expect(t1UserMsg.value).toMatchObject({ + type: 'event', + event: { + type: 'user/message', + surfaceOp: 'append', + data: { + role: 'user', + content: [{ type: 'text', text: 'First question' }], + source: { kind: 'user', rpcId: 'req_turn_1' }, + }, + }, + }) + + // Reply turn 1 + inboundHandler!({ + streamId: 'stream-1', + frame: { + method: 'session/update', + params: { + sessionId, + update: { sessionUpdate: 'agent_message_chunk', text: 'First answer' }, + }, + }, + }) + inboundHandler!({ + streamId: 'stream-1', + frame: { + method: 'session/update', + params: { + sessionId, + update: { sessionUpdate: 'prompt_completed', stopReason: 'end_turn' }, + }, + }, + }) + + // Consume stream frames for turn 1 + let frame = await iterator.next() + while ( + !frame.done && + !(frame.value as { event?: { type: string } }).event?.type?.includes('turn/end') + ) { + frame = await iterator.next() + } + + // Turn 2 prompt + await target.dispatch( + 'session/prompt', + { + args: { + request: { + sessionId, + requestId: 'req_turn_2', + content: [{ type: 'text', text: 'Second question' }], + }, + }, + }, + new AbortController().signal, + ) + + // Should receive turn/start (turn 2), step/start (turn 2), user/message with rpcId req_turn_2 + const t2TurnStart = await iterator.next() + expect(t2TurnStart.value).toMatchObject({ + type: 'event', + event: { type: 'turn/start', data: { turn: 2 } }, + }) + const t2StepStart = await iterator.next() + expect(t2StepStart.value).toMatchObject({ + type: 'event', + event: { type: 'step/start', data: { turn: 2, step: 1 } }, + }) + const t2UserMsg = await iterator.next() + expect(t2UserMsg.value).toMatchObject({ + type: 'event', + event: { + type: 'user/message', + surfaceOp: 'append', + data: { + role: 'user', + content: [{ type: 'text', text: 'Second question' }], + source: { kind: 'user', rpcId: 'req_turn_2' }, + }, + }, + }) + + followController.abort() + await iterator.return?.() + await target.close() + }, + }, + ]) + }, 10000) + + it('scopes workspace IDs by backend and rejects unscoped or other backend IDs', async () => { + const cursorId = acpCwdWorkspaceId('/workspace/repo', 'cursor') + const agyId = acpCwdWorkspaceId('/workspace/repo', 'antigravity') + expect(cursorId).toBe('cursor:cwd:%2Fworkspace%2Frepo') + expect(agyId).toBe('antigravity:cwd:%2Fworkspace%2Frepo') + expect(agyId).not.toBe(cursorId) + expect(() => acpCwdWorkspaceId('/workspace/repo', undefined as never)).toThrow('explicit ACP workspace backend') + const catalog = { ...fakeAcp(), listWorkspaces: vi.fn(async () => [{ path: '/workspace/repo' }]) } + expect((await discoverAcpVirtualWorkspaces(catalog, 'cursor'))[0].workspaceId).toBe(cursorId) + expect((await discoverAcpVirtualWorkspaces(catalog, 'antigravity'))[0].workspaceId).toBe(agyId) + const agy = new AcpVirtualHarness(fakeAcp(), { deviceId: 'host', name: 'Host' }, 'antigravity') + const cursor = new AcpVirtualHarness(fakeAcp(), { deviceId: 'host', name: 'Host' }) + try { + expect((await agy.selectWorkspace(agyId)).workspaceId).toBe(agyId) + expect((await cursor.selectWorkspace(cursorId)).workspaceId).toBe(cursorId) + await expect(agy.selectWorkspace(cursorId)).rejects.toThrow('no longer available') + await expect(agy.selectWorkspace('/workspace/repo')).rejects.toThrow('no longer available') + await expect(cursor.selectWorkspace('/workspace/repo')).rejects.toThrow('no longer available') + await expect(cursor.selectWorkspace(agyId)).rejects.toThrow('no longer available') + } finally { await agy.close(); await cursor.close() } + }) + + it('projects and toggles ACP permission presets and auto-approves requests under danger-full-access', async () => { + let onFrame!: (frame: AgentAcpFrameData) => void + const client = { + ...fakeAcp(), + openStream: vi.fn(async (_id: string, handler: typeof onFrame) => { onFrame = handler; return { close: async () => undefined } }), + respond: vi.fn(async () => ({})), + selectPermission: vi.fn(async () => ({})), + } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') + const signal = new AbortController().signal + try { + const workspace = await target.selectOrCreateWorkspace('/test') + const sessionId = workspace.sessionIds[0]! + const request = { sessionId } + + const initial = await target.dispatch('session/projections', { args: { request } }, signal) + expect(initial).toMatchObject({ + ok: true, + value: { + values: { + permissions: { + options: [ + { value: 'workspace-write' }, + { value: 'danger-full-access' }, + ], + currentValue: 'Host settings (not reported)', + }, + }, + }, + }) + + const commands = await target.dispatch('commands/list', { args: { request } }, signal) + expect(commands).toMatchObject({ ok: true, value: [{ name: 'permission' }] }) + + const switchResult = await target.dispatch('commands/execute', { args: { agentId: sessionId, line: '/permission danger-full-access', images: [] } }, signal) + expect(switchResult).toMatchObject({ ok: true, value: { result: { kind: 'success', text: 'preset danger-full-access' } } }) + expect(client.selectPermission).toHaveBeenCalledWith('remote-history', 'opencode', 'danger-full-access') + + const updated = await target.dispatch('session/projections', { args: { request } }, signal) + expect(updated).toMatchObject({ + ok: true, + value: { + values: { + permissions: { + currentValue: 'danger-full-access', + }, + }, + }, + }) + + const followStream = await target.open('session/follow', { args: { request } }, signal) + const iterator = followStream[Symbol.asyncIterator]() + await iterator.next() + + onFrame({ + frame: { + method: 'session/request_permission', + params: { + requestHandle: 'handle_1', + toolName: 'bash', + reason: 'execute command', + }, + }, + } as AgentAcpFrameData) + + expect(client.respond).toHaveBeenCalledWith('handle_1', 'allow-once') + + await target.dispatch('commands/execute', { args: { agentId: sessionId, line: '/permission workspace-write', images: [] } }, signal) + const reverted = await target.dispatch('session/projections', { args: { request } }, signal) + expect(reverted).toMatchObject({ + ok: true, + value: { + values: { + permissions: { + currentValue: 'workspace-write', + }, + }, + }, + }) + } finally { + await target.close() + } + }) +}) + +it.each(['claude', 'hermes'] as const)('%s routes direct files and terminal streams through ACP tools', async backend => { + const client = { ...fakeAcp(), workspaceToolCall: vi.fn(async () => ({ entries: [] })) } + const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend) + const signal = new AbortController().signal + const scope = `${backend}:saved` + try { + const args = { workspaceFileScopeId: scope, path: '.' } + expect(await target.dispatch('workspaceFiles/list', { args }, signal)).toMatchObject({ ok: true }) + expect(client.workspaceToolCall).toHaveBeenCalledWith('saved', backend, 'workspaceFiles/list', args, signal) + await target.open('terminal/follow', { args: { agentId: scope, id: 'term', attachmentId: 'attachment' } }, signal) + expect(client.openStream).toHaveBeenLastCalledWith('saved', expect.any(Function), expect.any(Function), signal, + { backend, endpoint: 'terminal/follow', args: { agentId: scope, id: 'term', attachmentId: 'attachment' } }) + } finally { await target.close() } +})