368 lines
20 KiB
TypeScript
368 lines
20 KiB
TypeScript
import { EventEmitter } from 'node:events'
|
|
import { access, mkdtemp, readFile, realpath, rm } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { OpencodeNativeApi } from '../src/acp/adapters/opencode-native-api.js'
|
|
import { PassThrough } from 'node:stream'
|
|
import type { ChildProcessWithoutNullStreams } from 'node:child_process'
|
|
import { describe, expect, it, vi } from 'vitest'
|
|
import { OpencodeAcpClient, OpencodeAcpError } from '../src/acp/adapters/opencode-process.js'
|
|
import type { SafeLogger } from '../src/logging.js'
|
|
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
|
|
|
|
describe('OpencodeAcpClient', () => {
|
|
it('negotiates native-listener and stdio-only CLIs without breaking ACP or weakening the private listener', async () => {
|
|
await runScenarios(['legacy', 'stdio'].map(mode => ({ name: mode, run: async () => {
|
|
const cwd = await realpath(await mkdtemp(join(tmpdir(), 'opencode CLI ')))
|
|
const client = new OpencodeAcpClient(process.execPath, logger(), undefined, {
|
|
cwd, args: [fileURLToPath(new URL('./fixtures/opencode-cli.mjs', import.meta.url)), 'acp', mode,
|
|
'--hostname', '0.0.0.0', '--port=4096', '--mdns', 'true', '--no-mdns=false', '--cwd', cwd],
|
|
})
|
|
try {
|
|
await Promise.all([client.start(), client.start()])
|
|
expect(client.isReady()).toBe(true)
|
|
await expect(client.call('session/list', {})).resolves.toMatchObject({ sessions: [{ sessionId: 'saved', cwd }] })
|
|
if (mode === 'legacy') {
|
|
await client.archiveSession('saved', cwd)
|
|
await expect(client.call('session/list', {})).resolves.toMatchObject({ sessions: [{ sessionId: 'saved', archived: true }] })
|
|
await expect(client.call('session/prompt', { sessionId: 'saved', prompt: [] })).rejects.toMatchObject({ code: 'ACP_SESSION_ARCHIVED' })
|
|
} else {
|
|
await expect(client.archiveSession('saved', cwd)).rejects.toMatchObject({ code: 'OPENCODE_ARCHIVE_UNAVAILABLE' })
|
|
await expect(client.call('session/load', { sessionId: 'saved', cwd, mcpServers: [] })).resolves.toMatchObject({ sessionId: 'saved' })
|
|
await expect(client.call('session/prompt', { sessionId: 'saved', prompt: [] })).resolves.toMatchObject({ stopReason: 'end_turn' })
|
|
await expect(client.history('saved', cwd)).resolves.toEqual([])
|
|
}
|
|
} finally { await client.close(); await rm(cwd, { recursive: true, force: true }) }
|
|
} })))
|
|
})
|
|
|
|
it('fails closed on uncertain CLI options and cancels probes without a late ACP launch', async () => {
|
|
await runScenarios(['probe-failure', 'probe-partial', 'probe-invalid', 'probe-overflow', 'probe-close', 'missing binary'].map(mode => ({ name: mode, run: async () => {
|
|
const cwd = await realpath(await mkdtemp(join(tmpdir(), 'opencode probe ')))
|
|
const client = new OpencodeAcpClient(mode === 'missing binary' ? join(cwd, 'missing') : process.execPath, logger(), undefined, {
|
|
cwd, args: [fileURLToPath(new URL('./fixtures/opencode-cli.mjs', import.meta.url)), 'acp', mode],
|
|
})
|
|
// Attach the rejection handler before closing a probe or spawning a missing binary.
|
|
const starting = client.start().then(() => undefined, error => error)
|
|
try {
|
|
if (mode === 'probe-close') {
|
|
await vi.waitFor(async () => { await access(join(cwd, 'probe-pid')) })
|
|
await client.close()
|
|
const pid = Number(await readFile(join(cwd, 'probe-pid'), 'utf8'))
|
|
await vi.waitFor(() => expect(() => process.kill(pid, 0)).toThrow())
|
|
}
|
|
const error = await starting
|
|
expect(error).toMatchObject({ code: mode === 'probe-close' ? 'OPENCODE_CLOSED' : mode === 'missing binary' ? 'OPENCODE_BINARY_UNAVAILABLE' : 'OPENCODE_CLI_PROBE_FAILED' })
|
|
expect(String(error)).not.toContain('private CLI configuration')
|
|
expect(client.isReady()).toBe(false)
|
|
await expect(access(join(cwd, 'acp-started'))).rejects.toThrow()
|
|
} finally { await client.close(); await rm(cwd, { recursive: true, force: true }) }
|
|
} })))
|
|
})
|
|
|
|
it('bounds isolated history readers and stops them with the parent during startup or load', async () => {
|
|
await runScenarios(['history', 'close during initialize', 'close during load', 'overflow'].map(scenario => ({ name: scenario, run: async () => {
|
|
const fake = fakeProcess()
|
|
const outbound: Array<{ method: string; id: number }> = []
|
|
const respond = (id: number, result: unknown) => fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`)
|
|
fake.child.stdin.on('data', chunk => {
|
|
for (const line of String(chunk).trim().split('\n')) {
|
|
const message = JSON.parse(line)
|
|
outbound.push(message)
|
|
if (message.method === 'initialize' && scenario !== 'close during initialize') respond(message.id, { protocolVersion: 1 })
|
|
if (message.method === 'session/load' && (scenario === 'history' || scenario === 'overflow')) {
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'session/update', params: { sessionId: 'saved',
|
|
update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: scenario === 'overflow' ? 'x'.repeat(8 * 1024 * 1024) : 'saved answer' } },
|
|
} })}\n`)
|
|
if (scenario === 'history') respond(message.id, {})
|
|
}
|
|
}
|
|
})
|
|
const client = new OpencodeAcpClient('opencode', logger(), () => fake.child)
|
|
const pending = client.history('saved', '/tmp').then(result => ({ result, error: undefined }), error => ({ result: undefined, error }))
|
|
try {
|
|
if (scenario.startsWith('close')) {
|
|
await vi.waitFor(() => expect(outbound.some(message => message.method === (scenario === 'close during initialize' ? 'initialize' : 'session/load'))).toBe(true))
|
|
await client.close()
|
|
}
|
|
const outcome = await pending
|
|
if (scenario === 'history') expect(outcome.result).toEqual(expect.arrayContaining([expect.objectContaining({ event: expect.objectContaining({ type: 'assistant/message' }) })]))
|
|
else expect(outcome.error).toMatchObject({ code: scenario === 'overflow' ? 'OPENCODE_HISTORY_TOO_LARGE' : 'OPENCODE_CLOSED' })
|
|
expect(fake.kill).toHaveBeenCalled()
|
|
expect(client.isReady()).toBe(false)
|
|
} finally { await client.close() }
|
|
} })))
|
|
})
|
|
|
|
it('uses upstream model contracts with session isolation, rejection and prompt exclusion', async () => {
|
|
await runScenarios(['configOptions', 'legacy'].map(format => ({ name: format, run: async () => {
|
|
const fake = fakeProcess()
|
|
const outbound: any[] = []
|
|
const selected = new Map<string, string>()
|
|
const efforts = new Map<string, string>()
|
|
let rejectChange = false
|
|
let confirmChange = true
|
|
const configuration = (id: string) => format === 'legacy'
|
|
? { models: { currentModelId: selected.get(id), availableModels: [{ modelId: 'provider/a', name: 'A' }, { modelId: 'provider/b', name: 'B' }] } }
|
|
: { configOptions: [{ id: 'model', type: 'select', currentValue: selected.get(id),
|
|
options: [{ name: 'Provider', options: [{ value: 'provider/a', name: 'A' }, { value: 'provider/b', name: 'B' }] }] },
|
|
...(selected.get(id) === 'provider/b' ? [{ id: 'effort', type: 'select', currentValue: efforts.get(id) ?? 'default',
|
|
options: [{ value: 'default', name: 'Default' }, { value: 'high', name: 'High' }] }] : [])] }
|
|
const respond = (message: any, result: unknown) => fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result })}\n`)
|
|
fake.child.stdin.on('data', chunk => {
|
|
for (const line of String(chunk).trim().split('\n')) {
|
|
const message = JSON.parse(line)
|
|
outbound.push(message)
|
|
if (message.method === 'initialize') respond(message, { protocolVersion: 1 })
|
|
if (message.method === 'session/load') {
|
|
selected.set(message.params.sessionId, 'provider/a')
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'session/update', params: {
|
|
sessionId: message.params.sessionId, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'old' } },
|
|
} })}\n`)
|
|
respond(message, configuration(message.params.sessionId))
|
|
}
|
|
if (['session/set_model', 'session/set_config_option'].includes(message.method)) {
|
|
if (rejectChange) fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, error: { code: -32602, message: 'invalid model' } })}\n`)
|
|
else {
|
|
if (confirmChange) {
|
|
if (message.params.configId === 'effort') efforts.set(message.params.sessionId, message.params.value)
|
|
else selected.set(message.params.sessionId, message.params.modelId ?? message.params.value)
|
|
}
|
|
respond(message, format === 'legacy' ? {} : configuration(message.params.sessionId))
|
|
}
|
|
}
|
|
}
|
|
})
|
|
const client = new OpencodeAcpClient('opencode', logger(), () => fake.child)
|
|
const inbound = vi.fn()
|
|
client.onInbound(inbound)
|
|
try {
|
|
await client.start()
|
|
await expect(client.call('dsh/sessionModels', { sessionId: 'missing' })).rejects.toThrow('Load the OpenCode session')
|
|
await Promise.all(['a', 'b'].map(sessionId => client.call('session/load', { sessionId, cwd: '/tmp', mcpServers: [] })))
|
|
expect(inbound).not.toHaveBeenCalled()
|
|
await expect(client.call('dsh/sessionModels', { sessionId: 'a' })).resolves.toMatchObject({
|
|
current: { model: 'provider/a' }, groups: [{ models: [{ id: 'provider/a' }, { id: 'provider/b' }] }],
|
|
})
|
|
const requestCount = outbound.length
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'invented' })).rejects.toThrow('unavailable')
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'provider/b', reasoningEffort: 'invented' })).rejects.toThrow()
|
|
expect(outbound).toHaveLength(requestCount)
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'provider/b' })).resolves.toMatchObject({ selected: { model: 'provider/b' } })
|
|
expect(outbound.at(-1)).toMatchObject({ method: format === 'legacy' ? 'session/set_model' : 'session/set_config_option',
|
|
params: format === 'legacy' ? { sessionId: 'a', modelId: 'provider/b' } : { sessionId: 'a', configId: 'model', value: 'provider/b' } })
|
|
await expect(client.call('dsh/sessionModels', { sessionId: 'b' })).resolves.toMatchObject({ current: { model: 'provider/a' } })
|
|
if (format === 'configOptions') {
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'provider/b', reasoningEffort: 'high' })).resolves.toMatchObject({ selected: { model: 'provider/b', reasoningEffort: 'high' } })
|
|
expect(outbound.at(-1)).toMatchObject({ method: 'session/set_config_option', params: { sessionId: 'a', configId: 'effort', value: 'high' } })
|
|
}
|
|
rejectChange = true
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'provider/a' })).rejects.toThrow()
|
|
await expect(client.call('dsh/sessionModels', { sessionId: 'a' })).resolves.toMatchObject({ current: { model: 'provider/b' } })
|
|
if (format === 'configOptions') {
|
|
rejectChange = false
|
|
confirmChange = false
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'provider/a' })).rejects.toThrow('did not confirm')
|
|
}
|
|
const prompt = client.call('session/prompt', { sessionId: 'a', prompt: [] })
|
|
await expect(client.call('dsh/selectModel', { sessionId: 'a', model: 'provider/a' })).rejects.toThrow('Stop the OpenCode reply')
|
|
await client.call('session/load', { sessionId: 'a', cwd: '/tmp', mcpServers: [] })
|
|
expect(outbound.filter(message => message.method === 'session/load')).toHaveLength(2)
|
|
respond(outbound.find(message => message.method === 'session/prompt'), { stopReason: 'end_turn' })
|
|
await prompt
|
|
await client.close()
|
|
await expect(client.call('dsh/sessionModels', { sessionId: 'a' })).rejects.toThrow('not ready')
|
|
} finally { await client.close() }
|
|
} })))
|
|
})
|
|
|
|
it('rechecks persisted native archive state without relying on a loaded-session cache', async () => {
|
|
const fake = fakeProcess()
|
|
const cwd = await realpath(process.cwd())
|
|
fake.child.stdin.on('data', chunk => {
|
|
for (const line of String(chunk).trim().split('\n')) {
|
|
const message = JSON.parse(line)
|
|
const result = message.method === 'initialize' ? { protocolVersion: 1 }
|
|
: { sessions: ['archived', 'active'].map(sessionId => ({ sessionId, cwd })), nextCursor: 'next-page' }
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result })}\n`)
|
|
}
|
|
})
|
|
const request = vi.fn(async (url: unknown) => {
|
|
const id = new URL(String(url)).pathname.split('/').at(-1)
|
|
return new Response(JSON.stringify({ id, directory: cwd, time: id === 'archived' ? { archived: 123 } : {} }))
|
|
})
|
|
const client = new OpencodeAcpClient('opencode', logger(), () => fake.child)
|
|
// Inject the native transport while retaining the real ACP request path.
|
|
Object.assign(client, { nativeApi: new OpencodeNativeApi('http://127.0.0.1:12345', request as typeof fetch) })
|
|
try {
|
|
await client.start()
|
|
await expect(client.call('session/list', {})).resolves.toMatchObject({
|
|
sessions: [{ sessionId: 'archived', archived: true }, { sessionId: 'active', archived: false }], nextCursor: 'next-page',
|
|
})
|
|
expect(request).toHaveBeenCalledTimes(2)
|
|
await expect(client.call('session/prompt', { sessionId: 'archived', prompt: [] })).rejects.toMatchObject({ code: 'ACP_SESSION_ARCHIVED' })
|
|
} finally { await client.close() }
|
|
})
|
|
|
|
it('initializes with standard ACP initialize and correlates JSON-RPC responses (without authenticate)', async () => {
|
|
const fake = fakeProcess()
|
|
const outbound: Array<Record<string, unknown>> = []
|
|
fake.child.stdin.on('data', chunk => {
|
|
for (const line of String(chunk).trim().split('\n')) {
|
|
if (!line) continue
|
|
const message = JSON.parse(line) as Record<string, unknown>
|
|
outbound.push(message)
|
|
if (message.method === 'initialize') {
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result: { protocolVersion: 1 } })}\n`)
|
|
}
|
|
}
|
|
})
|
|
const client = new OpencodeAcpClient('opencode-custom', logger(), binary => {
|
|
expect(binary).toBe('opencode-custom')
|
|
return fake.child
|
|
})
|
|
const inbound = vi.fn()
|
|
client.onInbound(inbound)
|
|
|
|
await client.start()
|
|
// OpenCode native ACP must only initialize, strictly no authenticate method
|
|
expect(outbound.map(message => message.method)).toEqual(['initialize'])
|
|
|
|
const pending = client.call('session/new', { cwd: '/tmp', mcpServers: [] })
|
|
await flush()
|
|
const request = outbound.find(message => message.method === 'session/new')!
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { sessionId: 'opc_sess_1' } })}\n`)
|
|
await expect(pending).resolves.toEqual({ sessionId: 'opc_sess_1' })
|
|
|
|
fake.stdout.write(`${JSON.stringify({
|
|
jsonrpc: '2.0',
|
|
method: 'session/update',
|
|
params: { sessionId: 'opc_sess_1', update: { sessionUpdate: 'agent_message_chunk' } },
|
|
})}\n`)
|
|
fake.stdout.write(`${JSON.stringify({
|
|
jsonrpc: '2.0',
|
|
id: 'perm-opc-1',
|
|
method: 'session/request_permission',
|
|
params: { sessionId: 'opc_sess_1' },
|
|
})}\n`)
|
|
await flush()
|
|
expect(inbound).toHaveBeenNthCalledWith(1, {
|
|
kind: 'notification',
|
|
method: 'session/update',
|
|
params: { sessionId: 'opc_sess_1', update: { sessionUpdate: 'agent_message_chunk' } },
|
|
})
|
|
expect(inbound).toHaveBeenNthCalledWith(2, {
|
|
kind: 'request',
|
|
id: 'perm-opc-1',
|
|
method: 'session/request_permission',
|
|
params: { sessionId: 'opc_sess_1' },
|
|
})
|
|
|
|
await client.respond('perm-opc-1', { outcome: { outcome: 'selected', optionId: 'allow-once' } })
|
|
expect(outbound.at(-1)).toEqual({
|
|
jsonrpc: '2.0',
|
|
id: 'perm-opc-1',
|
|
result: { outcome: { outcome: 'selected', optionId: 'allow-once' } },
|
|
})
|
|
await client.close()
|
|
})
|
|
|
|
it('sends session/cancel as a standard JSON-RPC notification without an id', async () => {
|
|
const fake = fakeProcess()
|
|
const outbound: Array<Record<string, unknown>> = []
|
|
fake.child.stdin.on('data', chunk => {
|
|
for (const line of String(chunk).trim().split('\n')) {
|
|
if (!line) continue
|
|
const message = JSON.parse(line) as Record<string, unknown>
|
|
outbound.push(message)
|
|
// Only requests (with an id) are answered; a notification must never get a reply.
|
|
if (message.method === 'initialize') {
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result: { protocolVersion: 1 } })}\n`)
|
|
}
|
|
}
|
|
})
|
|
const client = new OpencodeAcpClient('opencode', logger(), () => fake.child)
|
|
const pendingRequests = () => (client as unknown as { pending: Map<unknown, unknown> }).pending.size
|
|
try {
|
|
await client.start()
|
|
|
|
// A cancel arrives while a prompt is in flight and must not wait for upstream.
|
|
const prompt = client.call('session/prompt', { sessionId: 'sess_1', prompt: [] })
|
|
await flush()
|
|
expect(pendingRequests()).toBe(1)
|
|
|
|
await expect(client.call('session/cancel', { sessionId: 'sess_1' })).resolves.toEqual({})
|
|
expect(outbound.at(-1)).toEqual({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId: 'sess_1' } })
|
|
expect(outbound.at(-1)).not.toHaveProperty('id')
|
|
// Only the in-flight prompt stays pending: no cancel request was registered.
|
|
expect(pendingRequests()).toBe(1)
|
|
|
|
// Cancelling an idle session is likewise fire-and-forget.
|
|
const promptMessage = outbound.find(message => message.method === 'session/prompt')!
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: promptMessage.id, result: { stopReason: 'cancelled' } })}\n`)
|
|
await expect(prompt).resolves.toEqual({ stopReason: 'cancelled' })
|
|
await expect(client.call('session/cancel', { sessionId: 'sess_1' })).resolves.toEqual({})
|
|
expect(outbound.at(-1)).toEqual({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId: 'sess_1' } })
|
|
expect(pendingRequests()).toBe(0)
|
|
} finally { await client.close() }
|
|
})
|
|
|
|
it('rejects pending calls when process exits unexpectedly', async () => {
|
|
const fake = fakeProcess()
|
|
fake.child.stdin.on('data', chunk => {
|
|
for (const line of String(chunk).trim().split('\n')) {
|
|
if (!line) continue
|
|
const message = JSON.parse(line) as Record<string, unknown>
|
|
if (message.method === 'initialize') {
|
|
fake.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result: { protocolVersion: 1 } })}\n`)
|
|
}
|
|
}
|
|
})
|
|
const client = new OpencodeAcpClient('opencode', logger(), () => fake.child)
|
|
const nativeApi = new OpencodeNativeApi('http://127.0.0.1:12345')
|
|
const closeNative = vi.spyOn(nativeApi, 'close')
|
|
Object.assign(client, { nativeApi })
|
|
await client.start()
|
|
|
|
const pending = client.call('session/prompt', { sessionId: 'sess_1', prompt: [] })
|
|
await flush()
|
|
fake.child.emit('exit', 1, null)
|
|
|
|
await expect(pending).rejects.toThrow(OpencodeAcpError)
|
|
expect(closeNative).toHaveBeenCalledOnce()
|
|
})
|
|
})
|
|
|
|
function fakeProcess(): {
|
|
child: ChildProcessWithoutNullStreams
|
|
stdout: PassThrough
|
|
kill: ReturnType<typeof vi.fn>
|
|
} {
|
|
const stdout = new PassThrough()
|
|
const stderr = new PassThrough()
|
|
const stdin = new PassThrough()
|
|
const child = new EventEmitter() as ChildProcessWithoutNullStreams
|
|
const kill = vi.fn(() => {
|
|
child.emit('exit', 0, null)
|
|
return true
|
|
})
|
|
Object.assign(child, {
|
|
stdout,
|
|
stderr,
|
|
stdin,
|
|
kill,
|
|
exitCode: null,
|
|
killed: false,
|
|
})
|
|
return { child, stdout, kill }
|
|
}
|
|
|
|
function logger(): SafeLogger {
|
|
return { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() } as unknown as SafeLogger
|
|
}
|
|
|
|
async function flush(): Promise<void> {
|
|
await new Promise(resolve => setImmediate(resolve))
|
|
}
|