1983 lines
54 KiB
TypeScript
1983 lines
54 KiB
TypeScript
import { EventEmitter } from 'node:events'
|
||
import { createServer } from 'node:http'
|
||
import { mkdtemp, rm } from 'node:fs/promises'
|
||
import { tmpdir } from 'node:os'
|
||
import { join, resolve } from 'node:path'
|
||
import { PassThrough } from 'node:stream'
|
||
import type { createOpencodeClient } from '@opencode-ai/sdk/v2'
|
||
import type spawn from 'cross-spawn'
|
||
import { describe, expect, it, vi } from 'vitest'
|
||
import type { KnowledgeMcpGateway } from './knowledge-mcp-gateway'
|
||
import {
|
||
OpenCodeRuntime,
|
||
type OpenCodeRuntimeDependencies
|
||
} from './opencode-runtime'
|
||
|
||
type SpawnedProcess = ReturnType<typeof spawn>
|
||
|
||
function fakeChild(pid = 42): SpawnedProcess {
|
||
const child = new EventEmitter() as EventEmitter & {
|
||
stdout: PassThrough
|
||
stderr: PassThrough
|
||
exitCode: number | null
|
||
killed: boolean
|
||
pid: number
|
||
kill: ReturnType<typeof vi.fn>
|
||
unref: ReturnType<typeof vi.fn>
|
||
}
|
||
child.stdout = new PassThrough()
|
||
child.stderr = new PassThrough()
|
||
child.exitCode = null
|
||
child.killed = false
|
||
child.pid = pid
|
||
child.kill = vi.fn(() => {
|
||
child.killed = true
|
||
queueMicrotask(() => {
|
||
child.exitCode = 0
|
||
child.emit('close', 0, null)
|
||
})
|
||
return true
|
||
})
|
||
child.unref = vi.fn(() => child)
|
||
return child as unknown as SpawnedProcess
|
||
}
|
||
|
||
function fakeClient() {
|
||
return {
|
||
session: {
|
||
list: vi.fn().mockResolvedValue({ data: [], error: undefined })
|
||
}
|
||
} as unknown as ReturnType<typeof createOpencodeClient>
|
||
}
|
||
|
||
function stdoutOf(child: SpawnedProcess): PassThrough {
|
||
return child.stdout as PassThrough
|
||
}
|
||
|
||
function stderrOf(child: SpawnedProcess): PassThrough {
|
||
return child.stderr as PassThrough
|
||
}
|
||
|
||
function closeChild(child: SpawnedProcess, code: number): void {
|
||
;(child as unknown as { exitCode: number | null }).exitCode = code
|
||
child.emit('close', code, null)
|
||
}
|
||
|
||
function options(
|
||
overrides: Partial<ConstructorParameters<typeof OpenCodeRuntime>[0]> = {}
|
||
): ConstructorParameters<typeof OpenCodeRuntime>[0] {
|
||
return {
|
||
embedded: true,
|
||
binaryPath: '',
|
||
configPath: '',
|
||
defaultWorkspace: process.cwd(),
|
||
...overrides
|
||
}
|
||
}
|
||
|
||
function dependencies(
|
||
child: SpawnedProcess,
|
||
overrides: Partial<OpenCodeRuntimeDependencies> = {}
|
||
): {
|
||
deps: Partial<OpenCodeRuntimeDependencies>
|
||
spawnMock: ReturnType<typeof vi.fn>
|
||
detectBinary: ReturnType<typeof vi.fn>
|
||
createClient: ReturnType<typeof vi.fn>
|
||
} {
|
||
const spawnMock = vi.fn(() => child)
|
||
const detectBinary = vi.fn().mockResolvedValue({
|
||
path: 'opencode',
|
||
detail: 'OpenCode CLI 已就绪'
|
||
})
|
||
const createClient = vi.fn(() => fakeClient())
|
||
return {
|
||
deps: {
|
||
spawn: spawnMock as unknown as typeof spawn,
|
||
detectBinary,
|
||
createClient: createClient as unknown as typeof createOpencodeClient,
|
||
platform: 'linux',
|
||
startupTimeoutMs: 100,
|
||
...overrides
|
||
},
|
||
spawnMock,
|
||
detectBinary,
|
||
createClient
|
||
}
|
||
}
|
||
|
||
function permissionEvent(
|
||
overrides: Record<string, unknown> = {}
|
||
): Record<string, unknown> {
|
||
return {
|
||
id: 'event-1',
|
||
type: 'permission.asked',
|
||
properties: {
|
||
id: 'permission-1',
|
||
sessionID: 'session-1',
|
||
permission: 'bash',
|
||
patterns: ['npm test'],
|
||
metadata: { command: 'npm test' },
|
||
always: ['npm test'],
|
||
tool: {
|
||
messageID: 'message-1',
|
||
callID: 'call-1'
|
||
},
|
||
...overrides
|
||
}
|
||
}
|
||
}
|
||
|
||
function completedToolEvent(
|
||
callId = 'call-1',
|
||
tool = 'bash'
|
||
): Record<string, unknown> {
|
||
return {
|
||
id: `event-tool-${callId}`,
|
||
type: 'message.part.updated',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
part: {
|
||
id: `part-${callId}`,
|
||
callID: callId,
|
||
type: 'tool',
|
||
tool,
|
||
state: {
|
||
status: 'completed',
|
||
input: {
|
||
command: 'npm test',
|
||
token: 'visible-token'
|
||
},
|
||
output: 'Tests passed\nAuthorization: Bearer secret-token'
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function runClient(events: Record<string, unknown>[]) {
|
||
const callOrder: string[] = []
|
||
const permissionReply = vi.fn().mockResolvedValue({
|
||
data: true,
|
||
error: undefined
|
||
})
|
||
const questionReply = vi.fn().mockResolvedValue({
|
||
data: true,
|
||
error: undefined
|
||
})
|
||
const questionReject = vi.fn().mockResolvedValue({
|
||
data: true,
|
||
error: undefined
|
||
})
|
||
const client = {
|
||
session: {
|
||
list: vi.fn().mockResolvedValue({ data: [], error: undefined }),
|
||
create: vi.fn().mockResolvedValue({
|
||
data: { id: 'session-1' },
|
||
error: undefined
|
||
}),
|
||
update: vi.fn().mockResolvedValue({
|
||
data: { id: 'session-1' },
|
||
error: undefined
|
||
}),
|
||
promptAsync: vi.fn().mockImplementation(async () => {
|
||
callOrder.push('prompt')
|
||
return { data: true, error: undefined }
|
||
}),
|
||
abort: vi.fn().mockResolvedValue({
|
||
data: true,
|
||
error: undefined
|
||
}),
|
||
delete: vi.fn().mockResolvedValue({
|
||
data: true,
|
||
error: undefined
|
||
})
|
||
},
|
||
event: {
|
||
subscribe: vi.fn().mockImplementation(async () => {
|
||
callOrder.push('subscribe')
|
||
return {
|
||
stream: (async function* () {
|
||
for (const event of events) {
|
||
yield event
|
||
}
|
||
})()
|
||
}
|
||
})
|
||
},
|
||
permission: {
|
||
reply: permissionReply
|
||
},
|
||
question: {
|
||
reply: questionReply,
|
||
reject: questionReject
|
||
},
|
||
mcp: {
|
||
add: vi
|
||
.fn()
|
||
.mockImplementation(
|
||
async (input: { name: string }) => ({
|
||
data: {
|
||
[input.name]: { status: 'connected' }
|
||
},
|
||
error: undefined
|
||
})
|
||
),
|
||
disconnect: vi
|
||
.fn()
|
||
.mockResolvedValue({ data: true, error: undefined })
|
||
},
|
||
tool: {
|
||
ids: vi.fn().mockResolvedValue({
|
||
data: ['read', 'write', 'bash', 'task'],
|
||
error: undefined
|
||
})
|
||
}
|
||
} as unknown as ReturnType<typeof createOpencodeClient>
|
||
return {
|
||
client,
|
||
callOrder,
|
||
permissionReply,
|
||
questionReply,
|
||
questionReject,
|
||
session: client.session,
|
||
event: client.event,
|
||
tool: client.tool
|
||
}
|
||
}
|
||
|
||
function embeddedRuntime(
|
||
client: ReturnType<typeof createOpencodeClient>
|
||
): OpenCodeRuntime {
|
||
const child = fakeChild()
|
||
const { deps } = dependencies(child, {
|
||
createClient: vi.fn(
|
||
() => client
|
||
) as unknown as typeof createOpencodeClient
|
||
})
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:4010\n'
|
||
)
|
||
}, 0)
|
||
return new OpenCodeRuntime(options(), deps)
|
||
}
|
||
|
||
async function collectRun(
|
||
runtime: OpenCodeRuntime,
|
||
workMode: 'ask' | 'plan' | 'execute' = 'execute'
|
||
) {
|
||
const events = []
|
||
for await (const event of runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'test',
|
||
workMode
|
||
},
|
||
new AbortController().signal
|
||
)) {
|
||
events.push(event)
|
||
}
|
||
return events
|
||
}
|
||
|
||
describe('OpenCodeRuntime embedded launcher', () => {
|
||
it('uses the detected binary and passes an absolute config path only through env', async () => {
|
||
const serverChild = fakeChild(314)
|
||
const killerChild = fakeChild(315)
|
||
const detectBinary = vi.fn().mockResolvedValue({
|
||
path: 'C:\\Tools\\opencode.exe',
|
||
detail: 'OpenCode CLI 已就绪'
|
||
})
|
||
const createClient = vi.fn(() => fakeClient())
|
||
const spawnMock = vi.fn((command: string) => {
|
||
if (command === 'taskkill.exe') {
|
||
queueMicrotask(() => {
|
||
closeChild(serverChild, 0)
|
||
})
|
||
return killerChild
|
||
}
|
||
setTimeout(() => {
|
||
stdoutOf(serverChild).write(
|
||
'opencode server listening securely on http://127.0.0.1:43210\n'
|
||
)
|
||
}, 0)
|
||
return serverChild
|
||
})
|
||
const configPath = './private/opencode.json'
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
binaryPath: 'C:\\Configured\\opencode.exe',
|
||
configPath
|
||
}),
|
||
{
|
||
spawn: spawnMock as unknown as typeof spawn,
|
||
detectBinary,
|
||
createClient: createClient as unknown as typeof createOpencodeClient,
|
||
platform: 'win32'
|
||
}
|
||
)
|
||
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: true,
|
||
detail: '由 GoodBuddy 管理本机 OpenCode 进程'
|
||
})
|
||
expect(detectBinary).toHaveBeenCalledWith(
|
||
'opencode',
|
||
'C:\\Configured\\opencode.exe',
|
||
undefined
|
||
)
|
||
expect(spawnMock).toHaveBeenNthCalledWith(
|
||
1,
|
||
'C:\\Tools\\opencode.exe',
|
||
[
|
||
'serve',
|
||
'--hostname=127.0.0.1',
|
||
expect.stringMatching(/^--port=\d+$/u)
|
||
],
|
||
expect.objectContaining({
|
||
cwd: process.cwd(),
|
||
shell: false,
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
windowsHide: true,
|
||
env: expect.objectContaining({
|
||
OPENCODE_CONFIG: resolve(configPath)
|
||
})
|
||
})
|
||
)
|
||
const clientOptions = (
|
||
createClient.mock.calls as unknown as Array<
|
||
[
|
||
{
|
||
baseUrl?: string
|
||
directory?: string
|
||
headers?: Record<string, string>
|
||
}
|
||
]
|
||
>
|
||
)[0]?.[0] as
|
||
| {
|
||
baseUrl?: string
|
||
directory?: string
|
||
headers?: Record<string, string>
|
||
}
|
||
| undefined
|
||
expect(clientOptions).toMatchObject({
|
||
baseUrl: 'http://127.0.0.1:43210',
|
||
directory: process.cwd(),
|
||
headers: {
|
||
Authorization: expect.stringMatching(/^Basic /u)
|
||
}
|
||
})
|
||
const spawnOptions = (
|
||
spawnMock.mock.calls as unknown as Array<
|
||
[string, string[], { env?: NodeJS.ProcessEnv }]
|
||
>
|
||
)[0]?.[2] as
|
||
| { env?: NodeJS.ProcessEnv }
|
||
| undefined
|
||
expect(spawnOptions?.env?.OPENCODE_SERVER_USERNAME).toBe(
|
||
'goodbuddy'
|
||
)
|
||
expect(spawnOptions?.env?.OPENCODE_SERVER_PASSWORD).toBeTruthy()
|
||
expect(
|
||
Buffer.from(
|
||
clientOptions?.headers?.Authorization?.slice(6) ?? '',
|
||
'base64'
|
||
).toString()
|
||
).toBe(
|
||
`goodbuddy:${spawnOptions?.env?.OPENCODE_SERVER_PASSWORD}`
|
||
)
|
||
expect(runtime.requiresToolApproval).toBe(false)
|
||
|
||
await runtime.dispose()
|
||
|
||
expect(spawnMock).toHaveBeenNthCalledWith(
|
||
2,
|
||
'taskkill.exe',
|
||
['/PID', '314', '/T', '/F'],
|
||
{
|
||
shell: false,
|
||
stdio: 'ignore',
|
||
windowsHide: true
|
||
}
|
||
)
|
||
expect(killerChild.unref).toHaveBeenCalledOnce()
|
||
})
|
||
|
||
it('injects an independent model profile without persisting its key', async () => {
|
||
const child = fakeChild()
|
||
const { deps, spawnMock } = dependencies(child)
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:3011\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
modelProfile: {
|
||
id: '00000000-0000-4000-8000-000000000011',
|
||
name: '独立模型',
|
||
baseUrl: 'https://model.example',
|
||
modelName: 'private-model',
|
||
apiKey: 'private-key',
|
||
protocol: 'anthropic-messages',
|
||
authentication: 'api-key'
|
||
}
|
||
}),
|
||
deps
|
||
)
|
||
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: true
|
||
})
|
||
const spawnOptions = spawnMock.mock.calls[0]?.[2] as
|
||
| { env?: NodeJS.ProcessEnv }
|
||
| undefined
|
||
const config = JSON.parse(
|
||
spawnOptions?.env?.OPENCODE_CONFIG_CONTENT ?? '{}'
|
||
) as Record<string, unknown>
|
||
expect(config).toMatchObject({
|
||
model: 'goodbuddy-anthropic/private-model',
|
||
provider: {
|
||
'goodbuddy-anthropic': {
|
||
npm: '@ai-sdk/anthropic',
|
||
options: {
|
||
apiKey: 'private-key',
|
||
baseURL: 'https://model.example/v1'
|
||
},
|
||
models: {
|
||
'private-model': {
|
||
provider: {
|
||
npm: '@ai-sdk/anthropic'
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
})
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('isolates an explicit profile from unrelated inherited credentials', async () => {
|
||
const child = fakeChild()
|
||
const { deps, spawnMock } = dependencies(child)
|
||
const inheritedCredentials = {
|
||
ANTHROPIC_API_KEY: 'inherited-anthropic',
|
||
OPENAI_API_KEY: 'inherited-openai',
|
||
GOOGLE_GENERATIVE_AI_API_KEY: 'inherited-google',
|
||
GEMINI_API_KEY: 'inherited-gemini',
|
||
AWS_ACCESS_KEY_ID: 'inherited-aws-access',
|
||
AWS_SECRET_ACCESS_KEY: 'inherited-aws-secret',
|
||
AWS_SESSION_TOKEN: 'inherited-aws-session',
|
||
AWS_PROFILE: 'inherited-aws-profile',
|
||
OPENROUTER_API_KEY: 'inherited-openrouter'
|
||
}
|
||
const previousEnvironment = Object.fromEntries(
|
||
Object.keys(inheritedCredentials).map((name) => [
|
||
name,
|
||
process.env[name]
|
||
])
|
||
)
|
||
Object.assign(process.env, inheritedCredentials)
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:3013\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
modelProfile: {
|
||
id: '00000000-0000-4000-8000-000000000014',
|
||
name: 'Explicit OpenAI profile',
|
||
baseUrl: 'https://model.example/v1',
|
||
modelName: 'private-model',
|
||
protocol: 'openai-responses',
|
||
authentication: 'api-key',
|
||
apiKey: 'selected-openai-key'
|
||
}
|
||
}),
|
||
deps
|
||
)
|
||
|
||
try {
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: true
|
||
})
|
||
const environment = (
|
||
spawnMock.mock.calls[0]?.[2] as
|
||
| { env?: NodeJS.ProcessEnv }
|
||
| undefined
|
||
)?.env
|
||
expect(environment?.OPENAI_API_KEY).toBe('selected-openai-key')
|
||
for (const name of Object.keys(inheritedCredentials)) {
|
||
if (name !== 'OPENAI_API_KEY') {
|
||
expect(environment).not.toHaveProperty(name)
|
||
}
|
||
}
|
||
} finally {
|
||
await runtime.dispose()
|
||
for (const [name, value] of Object.entries(
|
||
previousEnvironment
|
||
)) {
|
||
if (value === undefined) {
|
||
delete process.env[name]
|
||
} else {
|
||
process.env[name] = value
|
||
}
|
||
}
|
||
}
|
||
})
|
||
|
||
it.each([
|
||
{
|
||
label: 'Chat Completions',
|
||
protocol: 'openai-chat-completions' as const,
|
||
expectedPath: '/v1/chat/completions',
|
||
unexpectedPath: '/v1/responses'
|
||
},
|
||
{
|
||
label: 'Responses',
|
||
protocol: 'openai-responses' as const,
|
||
expectedPath: '/v1/responses',
|
||
unexpectedPath: '/v1/chat/completions'
|
||
}
|
||
])(
|
||
'routes a custom-base $label profile through the bundled OpenCode provider',
|
||
async ({
|
||
protocol,
|
||
expectedPath,
|
||
unexpectedPath
|
||
}) => {
|
||
const root = await mkdtemp(
|
||
join(tmpdir(), 'goodbuddy-opencode-routing-')
|
||
)
|
||
const requestPaths: string[] = []
|
||
const server = createServer((request, response) => {
|
||
requestPaths.push(request.url ?? '')
|
||
request.resume()
|
||
response.writeHead(400, {
|
||
'content-type': 'application/json'
|
||
})
|
||
response.end(
|
||
JSON.stringify({
|
||
error: {
|
||
message: 'Intentional local routing probe'
|
||
}
|
||
})
|
||
)
|
||
})
|
||
await new Promise<void>((resolveListen, reject) => {
|
||
server.once('error', reject)
|
||
server.listen(0, '127.0.0.1', () => resolveListen())
|
||
})
|
||
const address = server.address()
|
||
if (!address || typeof address === 'string') {
|
||
throw new Error('Failed to bind local routing probe')
|
||
}
|
||
const isolatedEnvironment = {
|
||
APPDATA: join(root, 'appdata'),
|
||
HOME: root,
|
||
LOCALAPPDATA: join(root, 'localappdata'),
|
||
USERPROFILE: root
|
||
} as const
|
||
const previousEnvironment = Object.fromEntries(
|
||
Object.keys(isolatedEnvironment).map((name) => [
|
||
name,
|
||
process.env[name]
|
||
])
|
||
)
|
||
Object.assign(process.env, isolatedEnvironment)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
binaryPath: join(
|
||
process.cwd(),
|
||
'node_modules',
|
||
'opencode-ai',
|
||
'bin',
|
||
process.platform === 'win32'
|
||
? 'opencode.exe'
|
||
: 'opencode'
|
||
),
|
||
defaultWorkspace: root,
|
||
modelProfile: {
|
||
id: '00000000-0000-4000-8000-000000000013',
|
||
name: 'Local endpoint probe',
|
||
baseUrl: `http://127.0.0.1:${address.port}/v1`,
|
||
modelName: 'probe-model',
|
||
protocol,
|
||
authentication: 'api-key',
|
||
apiKey: 'local-probe-key'
|
||
}
|
||
})
|
||
)
|
||
const controller = new AbortController()
|
||
const timeout = setTimeout(
|
||
() => controller.abort(new Error('Routing probe timed out')),
|
||
20_000
|
||
)
|
||
try {
|
||
let failure = ''
|
||
await (async () => {
|
||
for await (const _event of runtime.run(
|
||
{
|
||
requestId:
|
||
'3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'routing-probe',
|
||
prompt: 'Reply with OK',
|
||
workMode: 'execute'
|
||
},
|
||
controller.signal
|
||
)) {
|
||
// The local probe intentionally returns an upstream error.
|
||
void _event
|
||
}
|
||
})().catch((error) => {
|
||
failure =
|
||
error instanceof Error ? error.message : String(error)
|
||
})
|
||
if (requestPaths.length === 0) {
|
||
throw new Error(`OpenCode routing probe failed: ${failure}`)
|
||
}
|
||
expect(requestPaths).toContain(expectedPath)
|
||
expect(requestPaths).not.toContain(unexpectedPath)
|
||
} finally {
|
||
clearTimeout(timeout)
|
||
await runtime.dispose()
|
||
for (const [name, value] of Object.entries(
|
||
previousEnvironment
|
||
)) {
|
||
if (value === undefined) {
|
||
delete process.env[name]
|
||
} else {
|
||
process.env[name] = value
|
||
}
|
||
}
|
||
await new Promise<void>((resolveClose, reject) => {
|
||
server.close((error) =>
|
||
error ? reject(error) : resolveClose()
|
||
)
|
||
})
|
||
await rm(root, { recursive: true, force: true })
|
||
}
|
||
},
|
||
30_000
|
||
)
|
||
|
||
it.each([
|
||
{
|
||
protocol: 'openai-chat-completions' as const,
|
||
authentication: 'none' as const,
|
||
providerId: 'goodbuddy-openai-chat',
|
||
providerPackage: '@ai-sdk/openai-compatible'
|
||
},
|
||
{
|
||
protocol: 'openai-responses' as const,
|
||
authentication: 'api-key' as const,
|
||
providerId: 'goodbuddy-openai-responses',
|
||
providerPackage: '@ai-sdk/openai'
|
||
}
|
||
])(
|
||
'generates an explicit $protocol provider configuration',
|
||
async ({
|
||
protocol,
|
||
authentication,
|
||
providerId,
|
||
providerPackage
|
||
}) => {
|
||
const child = fakeChild()
|
||
const { deps, spawnMock } = dependencies(child)
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:3012\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
modelProfile: {
|
||
id: '00000000-0000-4000-8000-000000000012',
|
||
name: 'OpenAI 独立模型',
|
||
baseUrl: 'https://model.example/v1',
|
||
modelName: 'custom-model',
|
||
protocol,
|
||
authentication,
|
||
...(authentication === 'api-key'
|
||
? { apiKey: 'private-key' }
|
||
: {})
|
||
}
|
||
}),
|
||
deps
|
||
)
|
||
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: true
|
||
})
|
||
const spawnOptions = spawnMock.mock.calls[0]?.[2] as
|
||
| { env?: NodeJS.ProcessEnv }
|
||
| undefined
|
||
const config = JSON.parse(
|
||
spawnOptions?.env?.OPENCODE_CONFIG_CONTENT ?? '{}'
|
||
) as {
|
||
model?: string
|
||
provider?: Record<
|
||
string,
|
||
{
|
||
npm?: string
|
||
options?: Record<string, unknown>
|
||
models?: Record<
|
||
string,
|
||
{ provider?: { npm?: string } }
|
||
>
|
||
}
|
||
>
|
||
}
|
||
expect(config.model).toBe(`${providerId}/custom-model`)
|
||
expect(config.provider?.[providerId]).toMatchObject({
|
||
npm: providerPackage,
|
||
options: {
|
||
baseURL: 'https://model.example/v1'
|
||
},
|
||
models: {
|
||
'custom-model': {
|
||
provider: {
|
||
npm: providerPackage
|
||
}
|
||
}
|
||
}
|
||
})
|
||
if (authentication === 'api-key') {
|
||
expect(
|
||
config.provider?.[providerId]?.options?.apiKey
|
||
).toBe('private-key')
|
||
} else {
|
||
expect(
|
||
config.provider?.[providerId]?.options
|
||
).not.toHaveProperty('apiKey')
|
||
}
|
||
await runtime.dispose()
|
||
}
|
||
)
|
||
|
||
it('isolates embedded server configuration from inherited env', async () => {
|
||
const child = fakeChild()
|
||
const { deps, spawnMock } = dependencies(child)
|
||
const isolatedNames = [
|
||
'OPENCODE_CONFIG',
|
||
'OPENCODE_CONFIG_CONTENT',
|
||
'OPENCODE_SERVER_PASSWORD',
|
||
'OPENCODE_SERVER_USERNAME'
|
||
] as const
|
||
const inherited = Object.fromEntries(
|
||
isolatedNames.map((name) => [name, process.env[name]])
|
||
)
|
||
const inheritedOtel = process.env.OTEL_EXPORTER_OTLP_ENDPOINT
|
||
for (const name of isolatedNames) {
|
||
process.env[name] = 'must-not-be-inherited'
|
||
}
|
||
process.env.OTEL_EXPORTER_OTLP_ENDPOINT =
|
||
'https://telemetry.invalid'
|
||
try {
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:3010\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(options(), deps)
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: true
|
||
})
|
||
|
||
const spawnOptions = spawnMock.mock.calls[0]?.[2] as
|
||
| { env?: NodeJS.ProcessEnv }
|
||
| undefined
|
||
expect(spawnOptions?.env?.OPENCODE_CONFIG).toBeUndefined()
|
||
expect(spawnOptions?.env?.OPENCODE_CONFIG_CONTENT).toBeUndefined()
|
||
expect(spawnOptions?.env?.OPENCODE_SERVER_USERNAME).toBe(
|
||
'goodbuddy'
|
||
)
|
||
expect(
|
||
spawnOptions?.env?.OPENCODE_SERVER_PASSWORD
|
||
).not.toBe('must-not-be-inherited')
|
||
expect(spawnOptions?.env).toMatchObject({
|
||
DO_NOT_TRACK: '1',
|
||
OPENCODE_DISABLE_AUTOUPDATE: '1',
|
||
OPENCODE_DISABLE_EMBEDDED_WEB_UI: '1',
|
||
OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
|
||
OPENCODE_DISABLE_MODELS_FETCH: '1',
|
||
OPENCODE_DISABLE_SHARE: '1',
|
||
OTEL_EXPORTER_OTLP_ENDPOINT: '',
|
||
OTEL_EXPORTER_OTLP_HEADERS: '',
|
||
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: '',
|
||
OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
|
||
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: '',
|
||
OTEL_SDK_DISABLED: 'true'
|
||
})
|
||
await runtime.dispose()
|
||
} finally {
|
||
for (const name of isolatedNames) {
|
||
const value = inherited[name]
|
||
if (value === undefined) {
|
||
delete process.env[name]
|
||
} else {
|
||
process.env[name] = value
|
||
}
|
||
}
|
||
if (inheritedOtel === undefined) {
|
||
delete process.env.OTEL_EXPORTER_OTLP_ENDPOINT
|
||
} else {
|
||
process.env.OTEL_EXPORTER_OTLP_ENDPOINT = inheritedOtel
|
||
}
|
||
}
|
||
})
|
||
|
||
it.each([
|
||
'https://127.0.0.1:4321',
|
||
'http://0.0.0.0:4321',
|
||
'http://example.com:4321',
|
||
'http://127.0.0.1',
|
||
'http://127.0.0.1:4321/admin'
|
||
])('rejects an unsafe listening URL: %s', async (url) => {
|
||
const child = fakeChild()
|
||
const { deps, createClient } = dependencies(child)
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(`opencode server listening on ${url}\n`)
|
||
closeChild(child, 7)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(options(), deps)
|
||
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: false,
|
||
detail: 'OpenCode Server 启动前退出（code 7）'
|
||
})
|
||
expect(createClient).not.toHaveBeenCalled()
|
||
})
|
||
|
||
it('times out, terminates the process tree, and does not expose stderr', async () => {
|
||
const child = fakeChild()
|
||
const secret = 'private-config-token'
|
||
const { deps } = dependencies(child, { startupTimeoutMs: 5 })
|
||
stderrOf(child).write(secret)
|
||
const runtime = new OpenCodeRuntime(options(), deps)
|
||
|
||
const status = await runtime.getStatus()
|
||
|
||
expect(status).toMatchObject({
|
||
available: false,
|
||
detail: 'OpenCode Server 启动超时（10 秒）'
|
||
})
|
||
expect(status.detail).not.toContain(secret)
|
||
expect(child.kill).toHaveBeenCalledWith('SIGTERM')
|
||
})
|
||
|
||
it('reports early exit without leaking captured stderr', async () => {
|
||
const child = fakeChild()
|
||
const secret = 'OPENCODE_CONFIG=/secret/config.json'
|
||
const { deps } = dependencies(child)
|
||
setTimeout(() => {
|
||
stderrOf(child).write(secret)
|
||
closeChild(child, 9)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(options(), deps)
|
||
|
||
const status = await runtime.getStatus()
|
||
|
||
expect(status.detail).toBe('OpenCode Server 启动前退出（code 9）')
|
||
expect(status.detail).not.toContain(secret)
|
||
})
|
||
|
||
it('terminates startup when the request is aborted', async () => {
|
||
const child = fakeChild()
|
||
const { deps, spawnMock } = dependencies(child)
|
||
const runtime = new OpenCodeRuntime(options(), deps)
|
||
const controller = new AbortController()
|
||
const stream = runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'test'
|
||
},
|
||
controller.signal
|
||
)
|
||
|
||
const pending = stream.next()
|
||
await vi.waitFor(() => expect(spawnMock).toHaveBeenCalledOnce())
|
||
controller.abort(new Error('sensitive abort reason'))
|
||
|
||
await expect(pending).rejects.toThrow('OpenCode Server 启动已取消')
|
||
expect(child.kill).toHaveBeenCalledWith('SIGTERM')
|
||
})
|
||
|
||
it('keeps external baseUrl mode free of binary detection and spawning', async () => {
|
||
const child = fakeChild()
|
||
const { deps, spawnMock, detectBinary, createClient } = dependencies(child)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
baseUrl: 'http://127.0.0.1:4096',
|
||
embedded: false
|
||
}),
|
||
deps
|
||
)
|
||
|
||
await expect(runtime.getStatus()).resolves.toMatchObject({
|
||
available: true,
|
||
detail: '已连接 http://127.0.0.1:4096'
|
||
})
|
||
expect(detectBinary).not.toHaveBeenCalled()
|
||
expect(spawnMock).not.toHaveBeenCalled()
|
||
expect(createClient).toHaveBeenCalledWith({
|
||
baseUrl: 'http://127.0.0.1:4096',
|
||
directory: process.cwd()
|
||
})
|
||
expect(runtime.requiresToolApproval).toBe(false)
|
||
})
|
||
|
||
it('loads assigned Skills before prompting', async () => {
|
||
const child = fakeChild()
|
||
const promptAsync = vi.fn().mockResolvedValue({ error: undefined })
|
||
const client = {
|
||
session: {
|
||
create: vi.fn().mockResolvedValue({ data: { id: 'session-1' } }),
|
||
promptAsync,
|
||
abort: vi.fn().mockResolvedValue(undefined)
|
||
},
|
||
event: {
|
||
subscribe: vi.fn().mockResolvedValue({
|
||
stream: (async function* () {
|
||
yield {
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
})()
|
||
})
|
||
},
|
||
tool: {
|
||
ids: vi.fn().mockResolvedValue({
|
||
data: ['read', 'write', 'goodbuddy-mcp'],
|
||
error: undefined
|
||
})
|
||
}
|
||
} as unknown as ReturnType<typeof createOpencodeClient>
|
||
const { deps } = dependencies(child, {
|
||
createClient: vi.fn(
|
||
() => client
|
||
) as unknown as typeof createOpencodeClient
|
||
})
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
baseUrl: 'http://127.0.0.1:4096',
|
||
embedded: false,
|
||
skillInstructions: '# 文档写作'
|
||
}),
|
||
deps
|
||
)
|
||
|
||
const events = []
|
||
for await (const event of runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'test',
|
||
workMode: 'execute'
|
||
},
|
||
new AbortController().signal
|
||
)) {
|
||
events.push(event)
|
||
}
|
||
|
||
expect(promptAsync).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
system: '# 文档写作',
|
||
parts: [{ type: 'text', text: 'test' }]
|
||
}),
|
||
expect.objectContaining({
|
||
signal: expect.any(AbortSignal)
|
||
})
|
||
)
|
||
expect(events.at(-1)).toMatchObject({ type: 'done' })
|
||
await runtime.dispose()
|
||
})
|
||
})
|
||
|
||
describe('OpenCodeRuntime embedded permission mediation', () => {
|
||
it('parses OpenCode questions and sends the selected answers back', async () => {
|
||
const setup = runClient([
|
||
{
|
||
id: 'question-event',
|
||
type: 'question.asked',
|
||
properties: {
|
||
id: 'question-1',
|
||
sessionID: 'session-1',
|
||
questions: [
|
||
{
|
||
header: '实现方式',
|
||
question: '请选择实现方式',
|
||
options: [
|
||
{
|
||
label: '直接修改',
|
||
description: '立即更新现有实现'
|
||
},
|
||
{
|
||
label: '先写测试',
|
||
description: '先增加回归测试'
|
||
}
|
||
],
|
||
multiple: false,
|
||
custom: true
|
||
}
|
||
],
|
||
tool: {
|
||
messageID: 'message-1',
|
||
callID: 'call-question-1'
|
||
}
|
||
}
|
||
},
|
||
{
|
||
id: 'idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(setup.client)
|
||
const stream = runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'test',
|
||
workMode: 'execute'
|
||
},
|
||
new AbortController().signal
|
||
)
|
||
|
||
await expect(stream.next()).resolves.toMatchObject({
|
||
value: { type: 'status' }
|
||
})
|
||
await expect(stream.next()).resolves.toMatchObject({
|
||
value: {
|
||
type: 'question',
|
||
questionId: 'question-1',
|
||
questions: [
|
||
{
|
||
header: '实现方式',
|
||
question: '请选择实现方式',
|
||
multiple: false,
|
||
custom: true
|
||
}
|
||
]
|
||
}
|
||
})
|
||
await runtime.respondToQuestion('question-1', [['先写测试']])
|
||
expect(setup.questionReply).toHaveBeenCalledWith({
|
||
requestID: 'question-1',
|
||
directory: process.cwd(),
|
||
answers: [['先写测试']]
|
||
})
|
||
await expect(stream.next()).resolves.toMatchObject({
|
||
value: { type: 'done' }
|
||
})
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('adds only the request-scoped knowledge MCP tool for Ask and disconnects it', async () => {
|
||
const setup = runClient([
|
||
{
|
||
id: 'idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const toolIds = setup.tool.ids as unknown as ReturnType<typeof vi.fn>
|
||
toolIds
|
||
.mockResolvedValueOnce({
|
||
data: ['read', 'write', 'bash'],
|
||
error: undefined
|
||
})
|
||
.mockResolvedValueOnce({
|
||
data: [
|
||
'read',
|
||
'write',
|
||
'bash',
|
||
'goodbuddy_knowledge_search'
|
||
],
|
||
error: undefined
|
||
})
|
||
.mockResolvedValue({
|
||
data: [
|
||
'read',
|
||
'write',
|
||
'bash',
|
||
'goodbuddy_knowledge_search'
|
||
],
|
||
error: undefined
|
||
})
|
||
const gateway = {
|
||
getEndpoint: () => 'http://127.0.0.1:4567/mcp'
|
||
} as unknown as KnowledgeMcpGateway
|
||
const child = fakeChild()
|
||
const { deps } = dependencies(child, {
|
||
createClient: vi.fn(
|
||
() => setup.client
|
||
) as unknown as typeof createOpencodeClient
|
||
})
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:4010\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({ knowledgeGateway: gateway }),
|
||
deps
|
||
)
|
||
|
||
const events = []
|
||
for await (const event of runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'search',
|
||
workMode: 'ask',
|
||
knowledgeCapabilityToken: 'secret-capability'
|
||
},
|
||
new AbortController().signal
|
||
)) {
|
||
events.push(event)
|
||
}
|
||
|
||
expect(setup.client.mcp.add).toHaveBeenCalledWith({
|
||
directory: process.cwd(),
|
||
name: expect.stringMatching(/^goodbuddy-knowledge-[a-f0-9]{20}$/u),
|
||
config: {
|
||
type: 'remote',
|
||
url: 'http://127.0.0.1:4567/mcp',
|
||
enabled: true,
|
||
headers: {
|
||
Authorization: 'Bearer secret-capability'
|
||
},
|
||
oauth: false
|
||
}
|
||
})
|
||
const knowledgeMcpName = (
|
||
(
|
||
setup.client.mcp.add as unknown as ReturnType<typeof vi.fn>
|
||
).mock.calls[0]?.[0] as { name: string }
|
||
).name
|
||
const knowledgeToolId = `${knowledgeMcpName}_knowledge_search`
|
||
expect(setup.session.create).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
permission: [
|
||
{ permission: '*', pattern: '*', action: 'deny' },
|
||
{
|
||
permission: knowledgeToolId,
|
||
pattern: '*',
|
||
action: 'allow'
|
||
}
|
||
]
|
||
})
|
||
)
|
||
expect(setup.session.promptAsync).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
tools: {
|
||
read: false,
|
||
write: false,
|
||
bash: false,
|
||
[knowledgeToolId]: true
|
||
}
|
||
}),
|
||
expect.anything()
|
||
)
|
||
expect(setup.client.mcp.disconnect).toHaveBeenCalledWith({
|
||
name: expect.stringMatching(/^goodbuddy-knowledge-/u),
|
||
directory: process.cwd()
|
||
})
|
||
expect(events.at(-1)).toMatchObject({ type: 'done' })
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('enables the deterministic MCP tool name when tool ids omit dynamic tools', async () => {
|
||
const setup = runClient([
|
||
{
|
||
id: 'idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const baseline = {
|
||
data: ['read', 'write', 'bash'],
|
||
error: undefined
|
||
}
|
||
const toolIds = setup.tool.ids as unknown as ReturnType<typeof vi.fn>
|
||
toolIds.mockResolvedValue(baseline)
|
||
const child = fakeChild()
|
||
const { deps } = dependencies(child, {
|
||
createClient: vi.fn(
|
||
() => setup.client
|
||
) as unknown as typeof createOpencodeClient
|
||
})
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:4010\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
knowledgeGateway: {
|
||
getEndpoint: () => 'http://127.0.0.1:4567/mcp'
|
||
} as unknown as KnowledgeMcpGateway
|
||
}),
|
||
deps
|
||
)
|
||
|
||
for await (const _event of runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'search',
|
||
workMode: 'ask',
|
||
knowledgeCapabilityToken: 'secret-capability'
|
||
},
|
||
new AbortController().signal
|
||
)) {
|
||
void _event
|
||
}
|
||
|
||
const knowledgeMcpName = (
|
||
(
|
||
setup.client.mcp.add as unknown as ReturnType<typeof vi.fn>
|
||
).mock.calls[0]?.[0] as { name: string }
|
||
).name
|
||
const knowledgeToolId = `${knowledgeMcpName}_knowledge_search`
|
||
expect(toolIds).toHaveBeenCalledTimes(1)
|
||
expect(setup.session.promptAsync).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
tools: expect.objectContaining({
|
||
read: false,
|
||
write: false,
|
||
bash: false,
|
||
[knowledgeToolId]: true
|
||
})
|
||
}),
|
||
expect.anything()
|
||
)
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('serializes overlapping embedded MCP registration and discovery', async () => {
|
||
const setup = runClient([
|
||
{
|
||
id: 'idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const toolIds = setup.tool.ids as unknown as ReturnType<typeof vi.fn>
|
||
const baseline = {
|
||
data: ['read', 'write'],
|
||
error: undefined
|
||
}
|
||
const withKnowledge = {
|
||
data: ['read', 'write', 'goodbuddy_knowledge_search'],
|
||
error: undefined
|
||
}
|
||
for (const response of [
|
||
baseline,
|
||
withKnowledge,
|
||
withKnowledge,
|
||
baseline,
|
||
withKnowledge,
|
||
withKnowledge
|
||
]) {
|
||
toolIds.mockResolvedValueOnce(response)
|
||
}
|
||
let resolveFirstAdd!: () => void
|
||
const firstAdd = new Promise<void>((resolve) => {
|
||
resolveFirstAdd = resolve
|
||
})
|
||
const mcpAdd = setup.client.mcp.add as unknown as ReturnType<typeof vi.fn>
|
||
mcpAdd
|
||
.mockImplementationOnce(async (input: { name: string }) => {
|
||
await firstAdd
|
||
return {
|
||
data: {
|
||
[input.name]: { status: 'connected' }
|
||
},
|
||
error: undefined
|
||
}
|
||
})
|
||
.mockImplementation(async (input: { name: string }) => ({
|
||
data: {
|
||
[input.name]: { status: 'connected' }
|
||
},
|
||
error: undefined
|
||
}))
|
||
const child = fakeChild()
|
||
const { deps } = dependencies(child, {
|
||
createClient: vi.fn(
|
||
() => setup.client
|
||
) as unknown as typeof createOpencodeClient
|
||
})
|
||
setTimeout(() => {
|
||
stdoutOf(child).write(
|
||
'opencode server listening on http://127.0.0.1:4010\n'
|
||
)
|
||
}, 0)
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
knowledgeGateway: {
|
||
getEndpoint: () => 'http://127.0.0.1:4567/mcp'
|
||
} as unknown as KnowledgeMcpGateway
|
||
}),
|
||
deps
|
||
)
|
||
const collect = async (
|
||
requestId: string,
|
||
conversationId: string,
|
||
token: string
|
||
): Promise<void> => {
|
||
for await (const _event of runtime.run(
|
||
{
|
||
requestId,
|
||
conversationId,
|
||
prompt: 'search',
|
||
workMode: 'ask',
|
||
knowledgeCapabilityToken: token
|
||
},
|
||
new AbortController().signal
|
||
)) {
|
||
void _event
|
||
}
|
||
}
|
||
|
||
const first = collect(
|
||
'3f496642-f47d-4e0a-8944-a32c77b0d6e1',
|
||
'conversation-one',
|
||
'first-token'
|
||
)
|
||
await vi.waitFor(() => expect(mcpAdd).toHaveBeenCalledTimes(1))
|
||
const second = collect(
|
||
'3f496642-f47d-4e0a-8944-a32c77b0d6e2',
|
||
'conversation-two',
|
||
'second-token'
|
||
)
|
||
await new Promise((resolve) => setTimeout(resolve, 10))
|
||
expect(mcpAdd).toHaveBeenCalledTimes(1)
|
||
|
||
resolveFirstAdd()
|
||
await first
|
||
await vi.waitFor(() => expect(mcpAdd).toHaveBeenCalledTimes(2))
|
||
await second
|
||
expect(
|
||
mcpAdd.mock.calls.map(
|
||
([input]) =>
|
||
(input as {
|
||
config: { headers: { Authorization: string } }
|
||
}).config.headers.Authorization
|
||
)
|
||
).toEqual(['Bearer first-token', 'Bearer second-token'])
|
||
expect(setup.client.mcp.disconnect).toHaveBeenCalledTimes(2)
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('does not send a knowledge capability to external OpenCode', async () => {
|
||
const setup = runClient([
|
||
{
|
||
id: 'idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
embedded: false,
|
||
baseUrl: 'http://127.0.0.1:4096',
|
||
knowledgeGateway: {
|
||
getEndpoint: () => 'http://127.0.0.1:4567/mcp'
|
||
} as unknown as KnowledgeMcpGateway
|
||
}),
|
||
{
|
||
createClient: vi.fn(
|
||
() => setup.client
|
||
) as unknown as typeof createOpencodeClient
|
||
}
|
||
)
|
||
for await (const _event of runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'search',
|
||
workMode: 'ask',
|
||
knowledgeCapabilityToken: 'must-not-leave-main'
|
||
},
|
||
new AbortController().signal
|
||
)) {
|
||
void _event
|
||
}
|
||
expect(setup.client.mcp.add).not.toHaveBeenCalled()
|
||
expect(
|
||
JSON.stringify(
|
||
(
|
||
setup.session.promptAsync as unknown as ReturnType<typeof vi.fn>
|
||
).mock.calls
|
||
)
|
||
).not.toContain('must-not-leave-main')
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('subscribes before prompting and auto-allows a tool request', async () => {
|
||
const {
|
||
client,
|
||
callOrder,
|
||
permissionReply,
|
||
session
|
||
} = runClient([
|
||
permissionEvent({ sessionID: 'unrelated-session' }),
|
||
permissionEvent(),
|
||
permissionEvent(),
|
||
completedToolEvent(),
|
||
{
|
||
id: 'event-reasoning-part',
|
||
type: 'message.part.updated',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
part: {
|
||
id: 'part-reasoning',
|
||
sessionID: 'session-1',
|
||
messageID: 'message-1',
|
||
type: 'reasoning',
|
||
text: '',
|
||
time: { start: 1 }
|
||
}
|
||
}
|
||
},
|
||
{
|
||
id: 'event-reasoning',
|
||
type: 'message.part.delta',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
messageID: 'message-1',
|
||
partID: 'part-reasoning',
|
||
field: 'text',
|
||
delta: 'reasoning output'
|
||
}
|
||
},
|
||
{
|
||
id: 'event-text',
|
||
type: 'message.part.delta',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
messageID: 'message-1',
|
||
partID: 'part-1',
|
||
field: 'text',
|
||
delta: 'approved output'
|
||
}
|
||
},
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
const events = await collectRun(runtime, 'execute')
|
||
|
||
expect(callOrder).toEqual(['subscribe', 'prompt'])
|
||
expect(session.create).toHaveBeenCalledWith({
|
||
title: 'GoodBuddy 对话',
|
||
directory: process.cwd(),
|
||
permission: [
|
||
{ permission: '*', pattern: '*', action: 'ask' },
|
||
{ permission: 'task', pattern: '*', action: 'deny' }
|
||
]
|
||
})
|
||
expect(permissionReply).toHaveBeenCalledOnce()
|
||
expect(permissionReply).toHaveBeenCalledWith({
|
||
requestID: 'permission-1',
|
||
directory: process.cwd(),
|
||
reply: 'once'
|
||
})
|
||
expect(events).toContainEqual(
|
||
expect.objectContaining({
|
||
type: 'reasoning',
|
||
delta: 'reasoning output'
|
||
})
|
||
)
|
||
expect(events).toContainEqual(
|
||
expect.objectContaining({
|
||
type: 'tool',
|
||
callId: 'call-1',
|
||
state: 'pending'
|
||
})
|
||
)
|
||
expect(events).toContainEqual(
|
||
expect.objectContaining({
|
||
type: 'tool',
|
||
callId: 'call-1',
|
||
state: 'completed',
|
||
input:
|
||
'{\n "command": "npm test",\n "token": "visible-token"\n}',
|
||
output:
|
||
'Tests passed\nAuthorization: Bearer secret-token'
|
||
})
|
||
)
|
||
expect(events).toContainEqual(
|
||
expect.objectContaining({
|
||
type: 'text',
|
||
delta: 'approved output'
|
||
})
|
||
)
|
||
expect(
|
||
events.filter(
|
||
(event) =>
|
||
event.type === 'reasoning' ||
|
||
event.type === 'text' ||
|
||
event.type === 'tool'
|
||
)
|
||
).toEqual([
|
||
expect.objectContaining({
|
||
type: 'tool',
|
||
callId: 'call-1',
|
||
state: 'pending'
|
||
}),
|
||
expect.objectContaining({
|
||
type: 'tool',
|
||
callId: 'call-1',
|
||
state: 'completed'
|
||
}),
|
||
expect.objectContaining({
|
||
type: 'reasoning',
|
||
delta: 'reasoning output'
|
||
}),
|
||
expect.objectContaining({
|
||
type: 'text',
|
||
delta: 'approved output'
|
||
})
|
||
])
|
||
expect(events.at(-1)).toMatchObject({ type: 'done' })
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('auto-allows each bounded tool request without GoodBuddy approval', async () => {
|
||
const { client, permissionReply } = runClient([
|
||
permissionEvent(),
|
||
permissionEvent({
|
||
id: 'permission-2',
|
||
patterns: ['npm run lint'],
|
||
metadata: { command: 'npm run lint' },
|
||
always: ['npm run lint'],
|
||
tool: {
|
||
messageID: 'message-2',
|
||
callID: 'call-2'
|
||
}
|
||
}),
|
||
completedToolEvent('call-1'),
|
||
completedToolEvent('call-2'),
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
await collectRun(runtime, 'execute')
|
||
|
||
expect(permissionReply.mock.calls).toEqual([
|
||
[
|
||
{
|
||
requestID: 'permission-1',
|
||
directory: process.cwd(),
|
||
reply: 'once'
|
||
}
|
||
],
|
||
[
|
||
{
|
||
requestID: 'permission-2',
|
||
directory: process.cwd(),
|
||
reply: 'once'
|
||
}
|
||
]
|
||
])
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('fails the run when a tool reports an error before session idle', async () => {
|
||
const { client, session } = runClient([
|
||
{
|
||
id: 'event-tool-error',
|
||
type: 'message.part.updated',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
part: {
|
||
id: 'part-1',
|
||
callID: 'call-1',
|
||
type: 'tool',
|
||
tool: 'write',
|
||
state: {
|
||
status: 'error',
|
||
error:
|
||
'write failed Authorization: Bearer secret-token'
|
||
}
|
||
}
|
||
}
|
||
},
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
const stream = runtime.run(
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
conversationId: 'conversation-1',
|
||
prompt: 'test',
|
||
workMode: 'execute'
|
||
},
|
||
new AbortController().signal
|
||
)
|
||
|
||
await expect(stream.next()).resolves.toMatchObject({
|
||
value: { type: 'status' }
|
||
})
|
||
await expect(stream.next()).resolves.toMatchObject({
|
||
value: {
|
||
type: 'tool',
|
||
callId: 'call-1',
|
||
state: 'failed',
|
||
error:
|
||
'write failed Authorization: Bearer secret-token'
|
||
}
|
||
})
|
||
await expect(stream.next()).rejects.toThrow(
|
||
'write failed Authorization: Bearer secret-token'
|
||
)
|
||
expect(session.abort).toHaveBeenCalledOnce()
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('surfaces a rejected async prompt instead of reporting success', async () => {
|
||
const { client, session } = runClient([
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
vi.mocked(session.promptAsync).mockResolvedValueOnce({
|
||
data: undefined,
|
||
error: {
|
||
data: {
|
||
message:
|
||
'prompt rejected Authorization: Bearer secret-token'
|
||
}
|
||
}
|
||
} as never)
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
await expect(collectRun(runtime)).rejects.toThrow(
|
||
'prompt rejected Authorization: Bearer secret-token'
|
||
)
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('deletes an ephemeral OpenCode session when released', async () => {
|
||
const { client, session } = runClient([
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
await collectRun(runtime)
|
||
await runtime.releaseConversation('conversation-1')
|
||
|
||
expect(session.delete).toHaveBeenCalledWith({
|
||
sessionID: 'session-1',
|
||
directory: process.cwd()
|
||
})
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('ignores unrelated requests and rejects bounded malformed requests without prompting', async () => {
|
||
const { client, permissionReply } = runClient([
|
||
permissionEvent({ sessionID: 'unrelated-session' }),
|
||
permissionEvent({
|
||
patterns: Array.from({ length: 33 }, () => '*')
|
||
}),
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
await collectRun(runtime, 'execute')
|
||
|
||
expect(permissionReply).toHaveBeenCalledOnce()
|
||
expect(permissionReply).toHaveBeenCalledWith({
|
||
requestID: 'permission-1',
|
||
directory: process.cwd(),
|
||
reply: 'reject'
|
||
})
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('fails closed when the OpenCode permission reply fails', async () => {
|
||
const { client, permissionReply, session } = runClient([
|
||
permissionEvent()
|
||
])
|
||
permissionReply.mockResolvedValue({
|
||
data: false,
|
||
error: { message: 'secret server error' }
|
||
})
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
await expect(
|
||
collectRun(runtime, 'execute')
|
||
).rejects.toThrow('OpenCode 权限回复失败')
|
||
expect(session.abort).toHaveBeenCalledWith({
|
||
sessionID: 'session-1',
|
||
directory: process.cwd()
|
||
})
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it.each(['ask', 'plan'] as const)(
|
||
'uses deny-all session rules and hard tool disable in %s mode',
|
||
async (workMode) => {
|
||
const { client, session, tool } = runClient([
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
await collectRun(runtime, workMode)
|
||
|
||
expect(session.create).toHaveBeenCalledWith({
|
||
title: 'GoodBuddy 对话',
|
||
directory: process.cwd(),
|
||
permission: [
|
||
{ permission: '*', pattern: '*', action: 'deny' }
|
||
]
|
||
})
|
||
expect(tool.ids).toHaveBeenCalledWith({
|
||
directory: process.cwd()
|
||
})
|
||
expect(session.promptAsync).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
tools: {
|
||
read: false,
|
||
write: false,
|
||
bash: false,
|
||
task: false
|
||
}
|
||
}),
|
||
expect.anything()
|
||
)
|
||
await runtime.dispose()
|
||
}
|
||
)
|
||
|
||
it('updates reused sessions when the work mode changes', async () => {
|
||
const { client, session } = runClient([
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
await collectRun(runtime, 'execute')
|
||
await collectRun(runtime, 'ask')
|
||
|
||
expect(session.update).toHaveBeenCalledWith({
|
||
sessionID: 'session-1',
|
||
directory: process.cwd(),
|
||
permission: [
|
||
{ permission: '*', pattern: '*', action: 'deny' }
|
||
]
|
||
})
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('leaves trusted external sessions unmodified and skips whole-run approval', async () => {
|
||
const { client, session, permissionReply } = runClient([
|
||
permissionEvent(),
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = new OpenCodeRuntime(
|
||
options({
|
||
baseUrl: 'http://127.0.0.1:4096',
|
||
embedded: false
|
||
}),
|
||
{
|
||
createClient: vi.fn(
|
||
() => client
|
||
) as unknown as typeof createOpencodeClient
|
||
}
|
||
)
|
||
await collectRun(runtime, 'execute')
|
||
|
||
expect(runtime.requiresToolApproval).toBe(false)
|
||
expect(session.create).toHaveBeenCalledWith({
|
||
title: 'GoodBuddy 对话',
|
||
directory: process.cwd()
|
||
})
|
||
expect(permissionReply).not.toHaveBeenCalled()
|
||
await runtime.dispose()
|
||
})
|
||
})
|
||
|
||
describe('OpenCodeRuntime model usage', () => {
|
||
it('emits one provider-reported usage event for each terminal assistant message', async () => {
|
||
const assistantMessage = {
|
||
id: 'message-assistant-1',
|
||
sessionID: 'session-1',
|
||
role: 'assistant',
|
||
time: {
|
||
created: 1,
|
||
completed: 2
|
||
},
|
||
parentID: 'message-user-1',
|
||
modelID: 'claude-sonnet-provider',
|
||
providerID: 'anthropic',
|
||
mode: 'build',
|
||
agent: 'build',
|
||
path: {
|
||
cwd: process.cwd(),
|
||
root: process.cwd()
|
||
},
|
||
cost: 0.01,
|
||
tokens: {
|
||
total: 42,
|
||
input: 23,
|
||
output: 11,
|
||
reasoning: 3,
|
||
cache: {
|
||
read: 7,
|
||
write: 5
|
||
}
|
||
}
|
||
}
|
||
const { client } = runClient([
|
||
{
|
||
id: 'event-incomplete',
|
||
type: 'message.updated',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
info: {
|
||
...assistantMessage,
|
||
time: { created: 1 }
|
||
}
|
||
}
|
||
},
|
||
{
|
||
id: 'event-terminal',
|
||
type: 'message.updated',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
info: assistantMessage
|
||
}
|
||
},
|
||
{
|
||
id: 'event-terminal-duplicate',
|
||
type: 'message.updated',
|
||
properties: {
|
||
sessionID: 'session-1',
|
||
info: assistantMessage
|
||
}
|
||
},
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
const events = await collectRun(runtime)
|
||
|
||
expect(
|
||
events.filter((event) => event.type === 'model-usage')
|
||
).toEqual([
|
||
{
|
||
requestId: '3f496642-f47d-4e0a-8944-a32c77b0d6ef',
|
||
type: 'model-usage',
|
||
callId: 'message-assistant-1',
|
||
runtime: 'opencode',
|
||
provider: 'anthropic',
|
||
model: 'claude-sonnet-provider',
|
||
inputTokens: 23,
|
||
outputTokens: 11,
|
||
cacheReadTokens: 7,
|
||
cacheWriteTokens: 5,
|
||
reportedTotalTokens: 42
|
||
}
|
||
])
|
||
expect(events.at(-2)).toMatchObject({ type: 'model-usage' })
|
||
expect(events.at(-1)).toMatchObject({ type: 'done' })
|
||
await runtime.dispose()
|
||
})
|
||
|
||
it('ignores assistant usage from another session', async () => {
|
||
const { client } = runClient([
|
||
{
|
||
id: 'event-unrelated-usage',
|
||
type: 'message.updated',
|
||
properties: {
|
||
sessionID: 'session-2',
|
||
info: {
|
||
id: 'message-assistant-2',
|
||
sessionID: 'session-2',
|
||
role: 'assistant',
|
||
time: {
|
||
created: 1,
|
||
completed: 2
|
||
},
|
||
parentID: 'message-user-2',
|
||
modelID: 'unrelated-model',
|
||
providerID: 'unrelated-provider',
|
||
mode: 'build',
|
||
agent: 'build',
|
||
path: {
|
||
cwd: process.cwd(),
|
||
root: process.cwd()
|
||
},
|
||
cost: 0,
|
||
tokens: {
|
||
input: 100,
|
||
output: 50,
|
||
reasoning: 0,
|
||
cache: {
|
||
read: 0,
|
||
write: 0
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
{
|
||
id: 'event-idle',
|
||
type: 'session.idle',
|
||
properties: { sessionID: 'session-1' }
|
||
}
|
||
])
|
||
const runtime = embeddedRuntime(client)
|
||
|
||
const events = await collectRun(runtime)
|
||
|
||
expect(
|
||
events.filter((event) => event.type === 'model-usage')
|
||
).toEqual([])
|
||
await runtime.dispose()
|
||
})
|
||
})
|