factory-factory 0.1.0

package/dist/src/backend/claude/permissions.test.js

@@ -0,0 +1,835 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { AutoApproveHandler, AutoDenyHandler, createAllowResponse, createDenyResponse, createPreToolUseHookResponse, createStopHookResponse, DeferredHandler, EDIT_TOOLS, ModeBasedHandler, READ_ONLY_TOOLS, shouldAutoApprove, } from './permissions.js';
+const canUseToolRequest = {
+    subtype: 'can_use_tool',
+    tool_name: 'Read',
+    input: { file_path: '/test.txt' },
+    tool_use_id: 'tool-123',
+};
+const bashToolRequest = {
+    subtype: 'can_use_tool',
+    tool_name: 'Bash',
+    input: { command: 'npm test' },
+    tool_use_id: 'tool-456',
+};
+const writeToolRequest = {
+    subtype: 'can_use_tool',
+    tool_name: 'Write',
+    input: { file_path: '/test.txt', content: 'hello' },
+    tool_use_id: 'tool-789',
+};
+const exitPlanModeRequest = {
+    subtype: 'can_use_tool',
+    tool_name: 'ExitPlanMode',
+    input: {},
+    tool_use_id: 'tool-exit',
+};
+const hookCallbackRequest = {
+    subtype: 'hook_callback',
+    callback_id: 'callback-123',
+    tool_use_id: 'tool-456',
+    input: {
+        session_id: 'session-123',
+        transcript_path: '/path/to/transcript',
+        cwd: '/project',
+        permission_mode: 'default',
+        hook_event_name: 'PreToolUse',
+        tool_name: 'Write',
+        tool_input: { file_path: '/test.txt' },
+    },
+};
+const stopHookRequest = {
+    subtype: 'hook_callback',
+    callback_id: 'stop-123',
+    input: {
+        session_id: 'session-123',
+        transcript_path: '/path/to/transcript',
+        cwd: '/project',
+        permission_mode: 'default',
+        hook_event_name: 'Stop',
+        stop_hook_active: true,
+    },
+};
+const hookWithoutToolName = {
+    subtype: 'hook_callback',
+    callback_id: 'callback-no-tool',
+    input: {
+        session_id: 'session-123',
+        transcript_path: '/path/to/transcript',
+        cwd: '/project',
+        permission_mode: 'default',
+        hook_event_name: 'PreToolUse',
+    },
+};
+describe('Tool Constants', () => {
+    describe('READ_ONLY_TOOLS', () => {
+        it('should contain Glob', () => {
+            expect(READ_ONLY_TOOLS.has('Glob')).toBe(true);
+        });
+        it('should contain Grep', () => {
+            expect(READ_ONLY_TOOLS.has('Grep')).toBe(true);
+        });
+        it('should contain Read', () => {
+            expect(READ_ONLY_TOOLS.has('Read')).toBe(true);
+        });
+        it('should contain NotebookRead', () => {
+            expect(READ_ONLY_TOOLS.has('NotebookRead')).toBe(true);
+        });
+        it('should contain Task', () => {
+            expect(READ_ONLY_TOOLS.has('Task')).toBe(true);
+        });
+        it('should contain TodoWrite', () => {
+            expect(READ_ONLY_TOOLS.has('TodoWrite')).toBe(true);
+        });
+        it('should contain TodoRead', () => {
+            expect(READ_ONLY_TOOLS.has('TodoRead')).toBe(true);
+        });
+        it('should not contain Write', () => {
+            expect(READ_ONLY_TOOLS.has('Write')).toBe(false);
+        });
+        it('should not contain Bash', () => {
+            expect(READ_ONLY_TOOLS.has('Bash')).toBe(false);
+        });
+        it('should have exactly 7 tools', () => {
+            expect(READ_ONLY_TOOLS.size).toBe(7);
+        });
+    });
+    describe('EDIT_TOOLS', () => {
+        it('should contain Write', () => {
+            expect(EDIT_TOOLS.has('Write')).toBe(true);
+        });
+        it('should contain Edit', () => {
+            expect(EDIT_TOOLS.has('Edit')).toBe(true);
+        });
+        it('should contain MultiEdit', () => {
+            expect(EDIT_TOOLS.has('MultiEdit')).toBe(true);
+        });
+        it('should contain UndoEdit', () => {
+            expect(EDIT_TOOLS.has('UndoEdit')).toBe(true);
+        });
+        it('should contain NotebookEdit', () => {
+            expect(EDIT_TOOLS.has('NotebookEdit')).toBe(true);
+        });
+        it('should not contain Bash', () => {
+            expect(EDIT_TOOLS.has('Bash')).toBe(false);
+        });
+        it('should not contain Read', () => {
+            expect(EDIT_TOOLS.has('Read')).toBe(false);
+        });
+        it('should have exactly 5 tools', () => {
+            expect(EDIT_TOOLS.size).toBe(5);
+        });
+    });
+});
+describe('shouldAutoApprove', () => {
+    describe('bypassPermissions mode', () => {
+        const mode = 'bypassPermissions';
+        it('should auto-approve Bash', () => {
+            expect(shouldAutoApprove(mode, 'Bash')).toBe(true);
+        });
+        it('should auto-approve Write', () => {
+            expect(shouldAutoApprove(mode, 'Write')).toBe(true);
+        });
+        it('should auto-approve Read', () => {
+            expect(shouldAutoApprove(mode, 'Read')).toBe(true);
+        });
+        it('should NOT auto-approve ExitPlanMode (interactive tool)', () => {
+            expect(shouldAutoApprove(mode, 'ExitPlanMode')).toBe(false);
+        });
+        it('should NOT auto-approve AskUserQuestion (interactive tool)', () => {
+            expect(shouldAutoApprove(mode, 'AskUserQuestion')).toBe(false);
+        });
+        it('should auto-approve any arbitrary tool', () => {
+            expect(shouldAutoApprove(mode, 'SomeRandomTool')).toBe(true);
+        });
+    });
+    describe('plan mode', () => {
+        const mode = 'plan';
+        it('should auto-approve Bash', () => {
+            expect(shouldAutoApprove(mode, 'Bash')).toBe(true);
+        });
+        it('should auto-approve Write', () => {
+            expect(shouldAutoApprove(mode, 'Write')).toBe(true);
+        });
+        it('should auto-approve Read', () => {
+            expect(shouldAutoApprove(mode, 'Read')).toBe(true);
+        });
+        it('should not auto-approve ExitPlanMode', () => {
+            expect(shouldAutoApprove(mode, 'ExitPlanMode')).toBe(false);
+        });
+        it('should auto-approve any other tool except ExitPlanMode', () => {
+            expect(shouldAutoApprove(mode, 'SomeRandomTool')).toBe(true);
+        });
+    });
+    describe('acceptEdits mode', () => {
+        const mode = 'acceptEdits';
+        it('should auto-approve Read (read-only)', () => {
+            expect(shouldAutoApprove(mode, 'Read')).toBe(true);
+        });
+        it('should auto-approve Glob (read-only)', () => {
+            expect(shouldAutoApprove(mode, 'Glob')).toBe(true);
+        });
+        it('should auto-approve Write (edit tool)', () => {
+            expect(shouldAutoApprove(mode, 'Write')).toBe(true);
+        });
+        it('should auto-approve Edit (edit tool)', () => {
+            expect(shouldAutoApprove(mode, 'Edit')).toBe(true);
+        });
+        it('should not auto-approve Bash', () => {
+            expect(shouldAutoApprove(mode, 'Bash')).toBe(false);
+        });
+        it('should not auto-approve unknown tools', () => {
+            expect(shouldAutoApprove(mode, 'SomeRandomTool')).toBe(false);
+        });
+    });
+    describe('default mode', () => {
+        const mode = 'default';
+        it('should auto-approve Read (read-only)', () => {
+            expect(shouldAutoApprove(mode, 'Read')).toBe(true);
+        });
+        it('should auto-approve Glob (read-only)', () => {
+            expect(shouldAutoApprove(mode, 'Glob')).toBe(true);
+        });
+        it('should auto-approve Grep (read-only)', () => {
+            expect(shouldAutoApprove(mode, 'Grep')).toBe(true);
+        });
+        it('should auto-approve Task (read-only)', () => {
+            expect(shouldAutoApprove(mode, 'Task')).toBe(true);
+        });
+        it('should not auto-approve Write', () => {
+            expect(shouldAutoApprove(mode, 'Write')).toBe(false);
+        });
+        it('should not auto-approve Edit', () => {
+            expect(shouldAutoApprove(mode, 'Edit')).toBe(false);
+        });
+        it('should not auto-approve Bash', () => {
+            expect(shouldAutoApprove(mode, 'Bash')).toBe(false);
+        });
+        it('should not auto-approve unknown tools', () => {
+            expect(shouldAutoApprove(mode, 'SomeRandomTool')).toBe(false);
+        });
+    });
+});
+describe('Helper Functions', () => {
+    describe('createAllowResponse', () => {
+        it('should return correct structure with empty updatedInput when not provided', () => {
+            const response = createAllowResponse();
+            expect(response).toEqual({ behavior: 'allow', updatedInput: {} });
+        });
+        it('should return correct structure with updatedInput', () => {
+            const updatedInput = { file_path: '/updated.txt' };
+            const response = createAllowResponse(updatedInput);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/updated.txt' },
+            });
+        });
+        it('should use empty object when undefined is passed', () => {
+            const response = createAllowResponse(undefined);
+            expect(response).toEqual({ behavior: 'allow', updatedInput: {} });
+            expect('updatedInput' in response).toBe(true);
+        });
+    });
+    describe('createDenyResponse', () => {
+        it('should return correct structure with message only', () => {
+            const response = createDenyResponse('Permission denied');
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: 'Permission denied',
+            });
+        });
+        it('should return correct structure with interrupt true', () => {
+            const response = createDenyResponse('Permission denied', true);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: 'Permission denied',
+                interrupt: true,
+            });
+        });
+        it('should return correct structure with interrupt false', () => {
+            const response = createDenyResponse('Permission denied', false);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: 'Permission denied',
+                interrupt: false,
+            });
+        });
+        it('should not include interrupt key when undefined', () => {
+            const response = createDenyResponse('Permission denied');
+            expect('interrupt' in response).toBe(false);
+        });
+    });
+    describe('createPreToolUseHookResponse', () => {
+        it('should return correct structure for allow decision', () => {
+            const response = createPreToolUseHookResponse('allow');
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'allow',
+                },
+            });
+        });
+        it('should return correct structure for deny decision', () => {
+            const response = createPreToolUseHookResponse('deny');
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                },
+            });
+        });
+        it('should return correct structure for ask decision', () => {
+            const response = createPreToolUseHookResponse('ask');
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'ask',
+                },
+            });
+        });
+        it('should include reason when provided', () => {
+            const response = createPreToolUseHookResponse('deny', 'Not allowed');
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'Not allowed',
+                },
+            });
+        });
+        it('should not include reason key when undefined', () => {
+            const response = createPreToolUseHookResponse('allow');
+            expect('permissionDecisionReason' in response.hookSpecificOutput).toBe(false);
+        });
+    });
+    describe('createStopHookResponse', () => {
+        it('should return correct structure for approve decision', () => {
+            const response = createStopHookResponse('approve');
+            expect(response).toEqual({ decision: 'approve' });
+        });
+        it('should return correct structure for block decision', () => {
+            const response = createStopHookResponse('block');
+            expect(response).toEqual({ decision: 'block' });
+        });
+        it('should include reason when provided', () => {
+            const response = createStopHookResponse('block', 'User blocked');
+            expect(response).toEqual({
+                decision: 'block',
+                reason: 'User blocked',
+            });
+        });
+        it('should not include reason key when undefined', () => {
+            const response = createStopHookResponse('approve');
+            expect('reason' in response).toBe(false);
+        });
+    });
+});
+describe('AutoApproveHandler', () => {
+    const handler = new AutoApproveHandler();
+    describe('onCanUseTool', () => {
+        it('should approve all tool requests with original input', async () => {
+            const response = await handler.onCanUseTool(canUseToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/test.txt' },
+            });
+        });
+        it('should approve Bash tool requests with original input', async () => {
+            const response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { command: 'npm test' },
+            });
+        });
+        it('should approve Write tool requests with original input', async () => {
+            const response = await handler.onCanUseTool(writeToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/test.txt', content: 'hello' },
+            });
+        });
+    });
+    describe('onPreToolUseHook', () => {
+        it('should allow all PreToolUse hooks', async () => {
+            const response = await handler.onPreToolUseHook(hookCallbackRequest);
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'allow',
+                },
+            });
+        });
+    });
+    describe('onStopHook', () => {
+        it('should approve all Stop hooks', async () => {
+            const response = await handler.onStopHook(stopHookRequest);
+            expect(response).toEqual({ decision: 'approve' });
+        });
+    });
+});
+describe('AutoDenyHandler', () => {
+    describe('with default message', () => {
+        const handler = new AutoDenyHandler();
+        it('should deny tool requests with default message', async () => {
+            const response = await handler.onCanUseTool(canUseToolRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: 'Tool execution not allowed',
+            });
+        });
+        it('should deny PreToolUse hooks with default message', async () => {
+            const response = await handler.onPreToolUseHook(hookCallbackRequest);
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'Tool execution not allowed',
+                },
+            });
+        });
+        it('should block Stop hooks with default message', async () => {
+            const response = await handler.onStopHook(stopHookRequest);
+            expect(response).toEqual({
+                decision: 'block',
+                reason: 'Tool execution not allowed',
+            });
+        });
+    });
+    describe('with custom message', () => {
+        const customMessage = 'Read-only mode active';
+        const handler = new AutoDenyHandler(customMessage);
+        it('should deny tool requests with custom message', async () => {
+            const response = await handler.onCanUseTool(canUseToolRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: customMessage,
+            });
+        });
+        it('should deny PreToolUse hooks with custom message', async () => {
+            const response = await handler.onPreToolUseHook(hookCallbackRequest);
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: customMessage,
+                },
+            });
+        });
+        it('should block Stop hooks with custom message', async () => {
+            const response = await handler.onStopHook(stopHookRequest);
+            expect(response).toEqual({
+                decision: 'block',
+                reason: customMessage,
+            });
+        });
+    });
+});
+describe('ModeBasedHandler', () => {
+    describe('default mode without onAsk', () => {
+        const handler = new ModeBasedHandler('default');
+        it('should auto-approve read-only tools with original input', async () => {
+            const response = await handler.onCanUseTool(canUseToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/test.txt' },
+            });
+        });
+        it('should deny non-read-only tools with message', async () => {
+            const response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: "Tool 'Bash' requires manual approval",
+            });
+        });
+        it('should deny Write tool', async () => {
+            const response = await handler.onCanUseTool(writeToolRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: "Tool 'Write' requires manual approval",
+            });
+        });
+    });
+    describe('default mode with onAsk callback', () => {
+        it('should call onAsk for non-auto-approved tools', async () => {
+            const onAsk = vi.fn().mockResolvedValue({ behavior: 'allow', updatedInput: {} });
+            const handler = new ModeBasedHandler('default', onAsk);
+            const response = await handler.onCanUseTool(bashToolRequest);
+            expect(onAsk).toHaveBeenCalledWith(bashToolRequest);
+            expect(response).toEqual({ behavior: 'allow', updatedInput: {} });
+        });
+        it('should not call onAsk for auto-approved tools', async () => {
+            const onAsk = vi.fn().mockResolvedValue({ behavior: 'allow', updatedInput: {} });
+            const handler = new ModeBasedHandler('default', onAsk);
+            await handler.onCanUseTool(canUseToolRequest);
+            expect(onAsk).not.toHaveBeenCalled();
+        });
+    });
+    describe('acceptEdits mode', () => {
+        const handler = new ModeBasedHandler('acceptEdits');
+        it('should auto-approve read-only tools with original input', async () => {
+            const response = await handler.onCanUseTool(canUseToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/test.txt' },
+            });
+        });
+        it('should auto-approve Write tool with original input', async () => {
+            const response = await handler.onCanUseTool(writeToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/test.txt', content: 'hello' },
+            });
+        });
+        it('should deny Bash tool', async () => {
+            const response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: "Tool 'Bash' requires manual approval",
+            });
+        });
+    });
+    describe('plan mode', () => {
+        const handler = new ModeBasedHandler('plan');
+        it('should auto-approve all tools except ExitPlanMode with original input', async () => {
+            const response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { command: 'npm test' },
+            });
+        });
+        it('should deny ExitPlanMode', async () => {
+            const response = await handler.onCanUseTool(exitPlanModeRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: "Tool 'ExitPlanMode' requires manual approval",
+            });
+        });
+    });
+    describe('bypassPermissions mode', () => {
+        const handler = new ModeBasedHandler('bypassPermissions');
+        it('should auto-approve all tools with original input', async () => {
+            const response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { command: 'npm test' },
+            });
+        });
+        it('should NOT auto-approve ExitPlanMode (interactive tool)', async () => {
+            const response = await handler.onCanUseTool(exitPlanModeRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: "Tool 'ExitPlanMode' requires manual approval",
+            });
+        });
+    });
+    describe('onPreToolUseHook', () => {
+        const handler = new ModeBasedHandler('default');
+        it('should allow hooks for read-only tools', async () => {
+            const readHook = {
+                ...hookCallbackRequest,
+                input: { ...hookCallbackRequest.input, tool_name: 'Read' },
+            };
+            const response = await handler.onPreToolUseHook(readHook);
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'allow',
+                },
+            });
+        });
+        it('should ask for hooks for non-read-only tools', async () => {
+            const response = await handler.onPreToolUseHook(hookCallbackRequest);
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'ask',
+                    permissionDecisionReason: "Tool 'Write' requires approval",
+                },
+            });
+        });
+        it('should ask when no tool name provided', async () => {
+            const response = await handler.onPreToolUseHook(hookWithoutToolName);
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'ask',
+                    permissionDecisionReason: 'No tool name provided',
+                },
+            });
+        });
+    });
+    describe('onStopHook', () => {
+        const handler = new ModeBasedHandler('default');
+        it('should always approve Stop hooks', async () => {
+            const response = await handler.onStopHook(stopHookRequest);
+            expect(response).toEqual({ decision: 'approve' });
+        });
+    });
+    describe('setMode and getMode', () => {
+        it('should update the mode', () => {
+            const handler = new ModeBasedHandler('default');
+            expect(handler.getMode()).toBe('default');
+            handler.setMode('bypassPermissions');
+            expect(handler.getMode()).toBe('bypassPermissions');
+        });
+        it('should change behavior after setMode', async () => {
+            const handler = new ModeBasedHandler('default');
+            let response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: "Tool 'Bash' requires manual approval",
+            });
+            handler.setMode('bypassPermissions');
+            response = await handler.onCanUseTool(bashToolRequest);
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { command: 'npm test' },
+            });
+        });
+    });
+});
+describe('DeferredHandler', () => {
+    let handler;
+    beforeEach(() => {
+        handler = new DeferredHandler({ timeout: 5000 });
+    });
+    afterEach(() => {
+        handler.cancelAll();
+    });
+    describe('event emission', () => {
+        it('should emit permission_request event for can_use_tool', async () => {
+            const eventHandler = vi.fn();
+            handler.on('permission_request', eventHandler);
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(eventHandler).toHaveBeenCalledWith(canUseToolRequest, 'tool-123');
+            handler.approve('tool-123');
+            await promise;
+        });
+        it('should emit hook_request event for PreToolUse hooks', async () => {
+            const eventHandler = vi.fn();
+            handler.on('hook_request', eventHandler);
+            const promise = handler.onPreToolUseHook(hookCallbackRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(eventHandler).toHaveBeenCalledWith(hookCallbackRequest, 'callback-123');
+            handler.approve('callback-123');
+            await promise;
+        });
+        it('should emit stop_request event for Stop hooks', async () => {
+            const eventHandler = vi.fn();
+            handler.on('stop_request', eventHandler);
+            const promise = handler.onStopHook(stopHookRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(eventHandler).toHaveBeenCalledWith(stopHookRequest, 'stop-123');
+            handler.approve('stop-123');
+            await promise;
+        });
+    });
+    describe('approve', () => {
+        it('should resolve pending permission request with original tool input', async () => {
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.approve('tool-123');
+            const response = await promise;
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/test.txt' },
+            });
+        });
+        it('should resolve pending permission request with updated input', async () => {
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.approve('tool-123', { file_path: '/updated.txt' });
+            const response = await promise;
+            expect(response).toEqual({
+                behavior: 'allow',
+                updatedInput: { file_path: '/updated.txt' },
+            });
+        });
+        it('should resolve PreToolUse hook with allow response', async () => {
+            const promise = handler.onPreToolUseHook(hookCallbackRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.approve('callback-123');
+            const response = await promise;
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'allow',
+                },
+            });
+        });
+        it('should resolve Stop hook with approve response', async () => {
+            const promise = handler.onStopHook(stopHookRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.approve('stop-123');
+            const response = await promise;
+            expect(response).toEqual({ decision: 'approve' });
+        });
+        it('should throw error for unknown request ID', () => {
+            expect(() => handler.approve('unknown-id')).toThrow('No pending request found with ID: unknown-id');
+        });
+    });
+    describe('deny', () => {
+        it('should resolve pending permission request with deny response', async () => {
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.deny('tool-123', 'User rejected');
+            const response = await promise;
+            expect(response).toEqual({
+                behavior: 'deny',
+                message: 'User rejected',
+            });
+        });
+        it('should resolve PreToolUse hook with deny response', async () => {
+            const promise = handler.onPreToolUseHook(hookCallbackRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.deny('callback-123', 'User rejected');
+            const response = await promise;
+            expect(response).toEqual({
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'User rejected',
+                },
+            });
+        });
+        it('should resolve Stop hook with block response', async () => {
+            const promise = handler.onStopHook(stopHookRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.deny('stop-123', 'User blocked');
+            const response = await promise;
+            expect(response).toEqual({
+                decision: 'block',
+                reason: 'User blocked',
+            });
+        });
+        it('should throw error for unknown request ID', () => {
+            expect(() => handler.deny('unknown-id', 'denied')).toThrow('No pending request found with ID: unknown-id');
+        });
+    });
+    describe('cancel', () => {
+        it('should reject pending request with error', async () => {
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.cancel('tool-123', 'Cancelled by user');
+            await expect(promise).rejects.toThrow('Cancelled by user');
+        });
+        it('should reject with default message when no reason provided', async () => {
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.cancel('tool-123');
+            await expect(promise).rejects.toThrow('Request cancelled');
+        });
+        it('should not throw for unknown request ID', () => {
+            expect(() => handler.cancel('unknown-id')).not.toThrow();
+        });
+    });
+    describe('cancelAll', () => {
+        it('should cancel all pending requests', async () => {
+            const promise1 = handler.onCanUseTool(canUseToolRequest);
+            const promise2 = handler.onPreToolUseHook(hookCallbackRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.cancelAll('Session ended');
+            await expect(promise1).rejects.toThrow('Session ended');
+            await expect(promise2).rejects.toThrow('Session ended');
+        });
+        it('should use default message when no reason provided', async () => {
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            handler.cancelAll();
+            await expect(promise).rejects.toThrow('All requests cancelled');
+        });
+        it('should clear pending count', async () => {
+            const promise1 = handler.onCanUseTool(canUseToolRequest);
+            const promise2 = handler.onPreToolUseHook(hookCallbackRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(handler.getPendingCount()).toBe(2);
+            handler.cancelAll();
+            expect(handler.getPendingCount()).toBe(0);
+            await expect(promise1).rejects.toThrow('All requests cancelled');
+            await expect(promise2).rejects.toThrow('All requests cancelled');
+        });
+    });
+    describe('timeout behavior', () => {
+        it('should reject request after timeout', async () => {
+            const shortTimeoutHandler = new DeferredHandler({ timeout: 50 });
+            const promise = shortTimeoutHandler.onCanUseTool(canUseToolRequest);
+            await expect(promise).rejects.toThrow('Permission request timed out after 50ms');
+        });
+        it('should not timeout with timeout=0', async () => {
+            const noTimeoutHandler = new DeferredHandler({ timeout: 0 });
+            const promise = noTimeoutHandler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(noTimeoutHandler.hasPendingRequest('tool-123')).toBe(true);
+            noTimeoutHandler.approve('tool-123');
+            await promise;
+        });
+    });
+    describe('utility methods', () => {
+        it('should track pending count correctly', async () => {
+            expect(handler.getPendingCount()).toBe(0);
+            const promise1 = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(handler.getPendingCount()).toBe(1);
+            const promise2 = handler.onPreToolUseHook(hookCallbackRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(handler.getPendingCount()).toBe(2);
+            handler.approve('tool-123');
+            await promise1;
+            expect(handler.getPendingCount()).toBe(1);
+            handler.cancel('callback-123');
+            await expect(promise2).rejects.toThrow('Request cancelled');
+            expect(handler.getPendingCount()).toBe(0);
+        });
+        it('should correctly identify pending requests', async () => {
+            expect(handler.hasPendingRequest('tool-123')).toBe(false);
+            const promise = handler.onCanUseTool(canUseToolRequest);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(handler.hasPendingRequest('tool-123')).toBe(true);
+            expect(handler.hasPendingRequest('unknown-id')).toBe(false);
+            handler.approve('tool-123');
+            await promise;
+            expect(handler.hasPendingRequest('tool-123')).toBe(false);
+        });
+    });
+    describe('generated request IDs', () => {
+        it('should generate unique request ID when tool_use_id is not provided', async () => {
+            const requestWithoutId = {
+                subtype: 'can_use_tool',
+                tool_name: 'Read',
+                input: { file_path: '/test.txt' },
+            };
+            const eventHandler = vi.fn();
+            handler.on('permission_request', eventHandler);
+            handler.onCanUseTool(requestWithoutId);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(eventHandler).toHaveBeenCalled();
+            const emittedId = eventHandler.mock.calls[0][1];
+            expect(emittedId).toMatch(/^deferred-\d+-\d+$/);
+            handler.approve(emittedId);
+        });
+        it('should use callback_id when provided (even empty string)', async () => {
+            const hookWithEmptyId = {
+                subtype: 'hook_callback',
+                callback_id: '',
+                input: {
+                    session_id: 'session-123',
+                    transcript_path: '/path/to/transcript',
+                    cwd: '/project',
+                    permission_mode: 'default',
+                    hook_event_name: 'PreToolUse',
+                    tool_name: 'Write',
+                },
+            };
+            const eventHandler = vi.fn();
+            handler.on('hook_request', eventHandler);
+            handler.onPreToolUseHook(hookWithEmptyId);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(eventHandler).toHaveBeenCalled();
+            const emittedId = eventHandler.mock.calls[0][1];
+            expect(emittedId).toBe('');
+            handler.approve('');
+        });
+    });
+});
+//# sourceMappingURL=permissions.test.js.map