import { beforeEach, describe, expect, it } from 'vitest' import { createHookListenerState } from './agent-hook-listener/listener-state' import { normalizeHookPayload } from './agent-hook-listener' import { makePaneKey } from './stable-pane-id' const PANE_KEY = makePaneKey('tab-1', '11111111-1111-4111-8111-111111111111') /** Live OpenCode 1.18.18 captures, also exercised through mimo-code’s shared normalizer. SDK EventPermissionAsked maps permission.asked properties * to PermissionRequest: permission names the tool, patterns the commands/paths, metadata holds untyped tool-specific fields. * Preserve captured metadata shapes: prior invented {} fixtures never exercised the real edit path. */ describe('OpenCode-family permission request status', () => { let state: ReturnType beforeEach(() => { state = createHookListenerState() }) const SOURCES = ['opencode', 'opencode2', 'mimo-code'] as const function permissionEvent( source: (typeof SOURCES)[number], properties: Record ): ReturnType { return normalizeHookPayload( state, source, { paneKey: PANE_KEY, payload: { hook_event_name: 'PermissionRequest', ...properties } }, 'production' ) } function lifecycleEvent( source: (typeof SOURCES)[number], eventName: string, properties: Record = {} ): ReturnType { return normalizeHookPayload( state, source, { paneKey: PANE_KEY, payload: { hook_event_name: eventName, ...properties } }, 'production' ) } const BASH_PERMISSION = { id: 'per_01', sessionID: 'ses_root', permission: 'bash', patterns: ['rm -rf build/'], metadata: { command: 'rm -rf build/' }, always: [] } it.each(SOURCES)('reports a permission request as waiting for %s', (source) => { const event = permissionEvent(source, BASH_PERMISSION) expect(event?.payload.state).toBe('waiting') expect(event?.payload.agentType).toBe(source) }) it.each(SOURCES)('names the requested permission as the tool for %s', (source) => { const event = permissionEvent(source, BASH_PERMISSION) // Permission name always identifies what is blocked; bare waiting hides it (STA-3160). expect(event?.payload.toolName).toBe('bash') }) it.each(SOURCES)('surfaces the blocked command as tool input for %s', (source) => { const event = permissionEvent(source, BASH_PERMISSION) expect(event?.payload.toolInput).toBe('rm -rf build/') }) it.each(SOURCES)('carries the real v2 shell request as an approval card for %s', (source) => { const event = permissionEvent(source, { id: 'per_native', sessionID: 'ses_native', permission: 'shell', patterns: ['printf PERMISSION_NATIVE_OK'], source: { type: 'tool', messageID: 'msg_native', id: 'functions.shell:0' } }) expect(event?.payload.interactivePrompt).toBe( JSON.stringify({ approval: { tool: 'shell', summary: 'printf PERMISSION_NATIVE_OK' } }) ) }) it.each(SOURCES)('names the edited file for %s', (source) => { // OpenCode 1.18.18 capture: edit uses filepath (one word) alongside the full patch. const event = permissionEvent(source, { id: 'per_02', sessionID: 'ses_root', permission: 'edit', patterns: ['private/tmp/oc-perm-probe/notes.md'], metadata: { filepath: '/private/tmp/oc-perm-probe/notes.md', diff: '@@ -0,0 +1,1 @@\n+hello world\n\\ No newline at end of file\n' }, always: ['*'] }) expect(event?.payload.toolName).toBe('edit') expect(event?.payload.toolInput).toBe('/private/tmp/oc-perm-probe/notes.md') }) it.each(SOURCES)('never previews a diff as the blocked target for %s', (source) => { const event = permissionEvent(source, { id: 'per_03', sessionID: 'ses_root', permission: 'edit', patterns: ['src/a.ts'], metadata: { diff: '@@ -1 +1 @@\n-before\n+after\n' }, always: [] }) // Why: `diff` is the largest field OpenCode sends and would swamp a one-line row. expect(event?.payload.toolInput).not.toContain('@@') }) it.each(SOURCES)('names the fetched url for %s', (source) => { // Captured verbatim from opencode 1.18.18. const event = permissionEvent(source, { id: 'per_04', sessionID: 'ses_root', permission: 'webfetch', patterns: ['https://example.com'], metadata: { url: 'https://example.com', format: 'markdown' }, always: ['*'] }) expect(event?.payload.toolName).toBe('webfetch') expect(event?.payload.toolInput).toBe('https://example.com') }) it.each(SOURCES)('falls back to patterns when metadata is unrecognized for %s', (source) => { // Unknown tools may use arbitrary metadata keys; patterns is the common permission fallback. const event = permissionEvent(source, { id: 'per_05', sessionID: 'ses_root', permission: 'some_mcp_tool', patterns: ['src/a.ts', 'src/b.ts'], metadata: { unrecognizedKey: 'ignored' }, always: [] }) expect(event?.payload.toolName).toBe('some_mcp_tool') expect(event?.payload.toolInput).toBe('src/a.ts, src/b.ts') }) it.each(SOURCES)( 'still reports waiting when the payload names no permission for %s', (source) => { // Unknown permission details cannot clear the blocked state; the user still owes an answer. const event = permissionEvent(source, { id: 'per_06', sessionID: 'ses_root' }) expect(event?.payload.state).toBe('waiting') expect(event?.payload.toolName).toBeUndefined() } ) it.each(SOURCES)('leaves the AskUserQuestion route untouched for %s', (source) => { const properties = { questions: [{ question: 'Choose', options: ['x', 'y'] }] } const event = normalizeHookPayload( state, source, { paneKey: PANE_KEY, payload: { hook_event_name: 'AskUserQuestion', ...properties } }, 'production' ) expect(event?.payload.state).toBe('waiting') expect(event?.payload.interactivePrompt).toBe(JSON.stringify(properties)) }) it.each(SOURCES)('clears permission metadata once the turn resumes for %s', (source) => { permissionEvent(source, BASH_PERMISSION) const resumed = lifecycleEvent(source, 'SessionBusy') // Retire answered approval details as work resumes so stale commands cannot appear live. expect(resumed?.payload.state).toBe('working') expect(resumed?.payload.toolName).toBeUndefined() expect(resumed?.payload.toolInput).toBeUndefined() expect(resumed?.payload.interactivePrompt).toBeUndefined() }) it.each(SOURCES)('retires the permission when the session goes idle for %s', (source) => { permissionEvent(source, BASH_PERMISSION) const idle = lifecycleEvent(source, 'SessionIdle') expect(idle?.payload.state).toBe('done') expect(idle?.payload.toolName).toBeUndefined() expect(idle?.payload.toolInput).toBeUndefined() expect(idle?.payload.interactivePrompt).toBeUndefined() }) it.each(SOURCES)( 'does not label a later question with the answered permission for %s', (source) => { permissionEvent(source, BASH_PERMISSION) const question = lifecycleEvent(source, 'AskUserQuestion', { questions: [{ question: 'Choose', options: ['x', 'y'] }] }) expect(question?.payload.state).toBe('waiting') expect(question?.payload.toolName).toBeUndefined() expect(question?.payload.toolInput).toBeUndefined() } ) it.each(SOURCES)('does not attribute the answered permission to a reply for %s', (source) => { permissionEvent(source, BASH_PERMISSION) const part = lifecycleEvent(source, 'MessagePart', { role: 'assistant', text: 'Ran it.' }) expect(part?.payload.lastAssistantMessage).toBe('Ran it.') expect(part?.payload.toolName).toBeUndefined() expect(part?.payload.toolInput).toBeUndefined() }) it.each(SOURCES)('does not carry an answered permission into a later wait for %s', (source) => { // Later ordinary waits also show tool fields, so answered permission details must be retired before the next question. permissionEvent(source, BASH_PERMISSION) lifecycleEvent(source, 'SessionBusy') lifecycleEvent(source, 'SessionIdle') const laterQuestion = lifecycleEvent(source, 'AskUserQuestion', { questions: [{ question: 'Which branch?', options: ['main', 'dev'] }] }) expect(laterQuestion?.payload.state).toBe('waiting') expect(laterQuestion?.payload.toolInput).toBeUndefined() expect(laterQuestion?.payload.toolName).toBeUndefined() }) it.each(SOURCES)('does not carry an answered permission into a later turn for %s', (source) => { // This family lacks mid-session isNewTurnEvent resets; explicitly retire permissions or their commands persist across later turns. permissionEvent(source, BASH_PERMISSION) lifecycleEvent(source, 'SessionBusy') lifecycleEvent(source, 'SessionIdle') const laterTurn = lifecycleEvent(source, 'SessionBusy') expect(laterTurn?.payload.state).toBe('working') expect(laterTurn?.payload.toolInput).toBeUndefined() expect(laterTurn?.payload.toolName).toBeUndefined() }) })