@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc2

package/dist/src/ui/AppContainer.test.js

@@ -5,13 +5,28 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { render, cleanup } from 'ink-testing-library';
+import { render } from '../test-utils/render.js';
+import { cleanup } from 'ink-testing-library';
+import { act, useContext } from 'react';
 import { AppContainer } from './AppContainer.js';
-import { makeFakeConfig } from '@google/gemini-cli-core';
+import { makeFakeConfig, CoreEvent, } from '@google/gemini-cli-core';
+// Mock coreEvents
+const mockCoreEvents = vi.hoisted(() => ({
+    on: vi.fn(),
+    off: vi.fn(),
+    drainFeedbackBacklog: vi.fn(),
+    emit: vi.fn(),
+}));
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        coreEvents: mockCoreEvents,
+    };
+});
 import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
 import { UIStateContext } from './contexts/UIStateContext.js';
 import { UIActionsContext, } from './contexts/UIActionsContext.js';
-import { useContext } from 'react';
 // Mock useStdout to capture terminal title writes
 let mockStdout;
 vi.mock('ink', async (importOriginal) => {
@@ -66,6 +81,10 @@ vi.mock('../utils/events.js');
 vi.mock('../utils/handleAutoUpdate.js');
 vi.mock('./utils/ConsolePatcher.js');
 vi.mock('../utils/cleanup.js');
+vi.mock('./utils/mouse.js', () => ({
+    enableMouseEvents: vi.fn(),
+    disableMouseEvents: vi.fn(),
+}));
 import { useHistory } from './hooks/useHistoryManager.js';
 import { useThemeCommand } from './hooks/useThemeCommand.js';
 import { useAuthCommand } from './auth/useAuth.js';
@@ -86,13 +105,17 @@ import { useSessionStats } from './contexts/SessionContext.js';
 import { useTextBuffer } from './components/shared/text-buffer.js';
 import { useLogger } from './hooks/useLogger.js';
 import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
+import { useKeypress } from './hooks/useKeypress.js';
 import { measureElement } from 'ink';
 import { useTerminalSize } from './hooks/useTerminalSize.js';
 import { ShellExecutionService } from '@google/gemini-cli-core';
+import {} from '../config/extension-manager.js';
+import { enableMouseEvents, disableMouseEvents } from './utils/mouse.js';
 describe('AppContainer State Management', () => {
     let mockConfig;
     let mockSettings;
     let mockInitResult;
+    let mockExtensionManager;
     // Create typed mocks for all hooks
     const mockedUseQuotaAndFallback = useQuotaAndFallback;
     const mockedUseHistory = useHistory;
@@ -115,6 +138,7 @@ describe('AppContainer State Management', () => {
     const mockedUseTextBuffer = useTextBuffer;
     const mockedUseLogger = useLogger;
     const mockedUseLoadingIndicator = useLoadingIndicator;
+    const mockedUseKeypress = useKeypress;
     beforeEach(() => {
         vi.clearAllMocks();
         // Initialize mock stdout for terminal title tests
@@ -235,6 +259,13 @@ describe('AppContainer State Management', () => {
         mockConfig = makeFakeConfig();
         // Mock config's getTargetDir to return consistent workspace directory
         vi.spyOn(mockConfig, 'getTargetDir').mockReturnValue('/test/workspace');
+        mockExtensionManager = vi.mockObject({
+            getExtensions: vi.fn().mockReturnValue([]),
+            setRequestConsent: vi.fn(),
+            setRequestSetting: vi.fn(),
+            start: vi.fn(),
+        });
+        vi.spyOn(mockConfig, 'getExtensionLoader').mockReturnValue(mockExtensionManager);
         // Mock LoadedSettings
         mockSettings = {
             merged: {
@@ -261,27 +292,33 @@ describe('AppContainer State Management', () => {
         cleanup();
     });
     describe('Basic Rendering', () => {
-        it('renders without crashing with minimal props', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('renders without crashing with minimal props', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('renders with startup warnings', () => {
+        it('renders with startup warnings', async () => {
             const startupWarnings = ['Warning 1', 'Warning 2'];
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, startupWarnings: startupWarnings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, startupWarnings: startupWarnings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('State Initialization', () => {
-        it('initializes with theme error from initialization result', () => {
+        it('initializes with theme error from initialization result', async () => {
             const initResultWithError = {
                 ...mockInitResult,
                 themeError: 'Failed to load theme',
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: initResultWithError }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: initResultWithError }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
         it('handles debug mode state', () => {
             const debugConfig = makeFakeConfig();
@@ -292,29 +329,38 @@ describe('AppContainer State Management', () => {
         });
     });
     describe('Context Providers', () => {
-        it('provides AppContext with correct values', () => {
+        it('provides AppContext with correct values', async () => {
             const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "2.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Should render and unmount cleanly
             expect(() => unmount()).not.toThrow();
         });
-        it('provides UIStateContext with state management', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('provides UIStateContext with state management', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('provides UIActionsContext with action handlers', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('provides UIActionsContext with action handlers', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('provides ConfigContext with config object', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('provides ConfigContext with config object', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Settings Integration', () => {
-        it('handles settings with all display options disabled', () => {
+        it('handles settings with all display options disabled', async () => {
             const settingsAllHidden = {
                 merged: {
                     hideBanner: true,
@@ -323,11 +369,13 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: false,
                 },
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: settingsAllHidden, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: settingsAllHidden, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('handles settings with memory usage enabled', () => {
+        it('handles settings with memory usage enabled', async () => {
             const settingsWithMemory = {
                 merged: {
                     hideBanner: false,
@@ -336,36 +384,44 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: true,
                 },
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: settingsWithMemory, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: settingsWithMemory, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Version Handling', () => {
-        it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', (version) => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: version, initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', async (version) => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: version, initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Error Handling', () => {
-        it('handles config methods that might throw', () => {
+        it('handles config methods that might throw', async () => {
             const errorConfig = makeFakeConfig();
             vi.spyOn(errorConfig, 'getModel').mockImplementation(() => {
                 throw new Error('Config error');
             });
             // Should still render without crashing - errors should be handled internally
-            expect(() => {
-                render(_jsx(AppContainer, { config: errorConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: errorConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('handles undefined settings gracefully', () => {
+        it('handles undefined settings gracefully', async () => {
             const undefinedSettings = {
                 merged: {},
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: undefinedSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: undefinedSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Provider Hierarchy', () => {
@@ -377,13 +433,17 @@ describe('AppContainer State Management', () => {
         });
     });
     describe('Quota and Fallback Integration', () => {
-        it('passes a null proQuotaRequest to UIStateContext by default', () => {
+        it('passes a null proQuotaRequest to UIStateContext by default', async () => {
             // The default mock from beforeEach already sets proQuotaRequest to null
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert that the context value is as expected
             expect(capturedUIState.proQuotaRequest).toBeNull();
+            unmount();
         });
-        it('passes a valid proQuotaRequest to UIStateContext when provided by the hook', () => {
+        it('passes a valid proQuotaRequest to UIStateContext when provided by the hook', async () => {
             // Arrange: Create a mock request object that a UI dialog would receive
             const mockRequest = {
                 failedModel: 'gemini-pro',
@@ -395,11 +455,15 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: vi.fn(),
             });
             // Act: Render the container
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert: The mock request is correctly passed through the context
             expect(capturedUIState.proQuotaRequest).toEqual(mockRequest);
+            unmount();
         });
-        it('passes the handleProQuotaChoice function to UIActionsContext', () => {
+        it('passes the handleProQuotaChoice function to UIActionsContext', async () => {
             // Arrange: Create a mock handler function
             const mockHandler = vi.fn();
             mockedUseQuotaAndFallback.mockReturnValue({
@@ -407,12 +471,18 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: mockHandler,
             });
             // Act: Render the container
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert: The action in the context is the mock handler we provided
             expect(capturedUIActions.handleProQuotaChoice).toBe(mockHandler);
             // You can even verify that the plumbed function is callable
-            capturedUIActions.handleProQuotaChoice('auth');
+            act(() => {
+                capturedUIActions.handleProQuotaChoice('auth');
+            });
             expect(mockHandler).toHaveBeenCalledWith('auth');
+            unmount();
         });
     });
     describe('Terminal Title Update Feature', () => {
@@ -661,37 +731,59 @@ describe('AppContainer State Management', () => {
             vi.useRealTimers();
         });
         it('should set and clear the queue error message after a timeout', async () => {
-            const { rerender } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { rerender, unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
+            });
             expect(capturedUIState.queueErrorMessage).toBeNull();
-            capturedUIActions.setQueueErrorMessage('Test error');
+            act(() => {
+                capturedUIActions.setQueueErrorMessage('Test error');
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('Test error');
-            vi.advanceTimersByTime(3000);
+            act(() => {
+                vi.advanceTimersByTime(3000);
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBeNull();
+            unmount();
         });
         it('should reset the timer if a new error message is set', async () => {
-            const { rerender } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            capturedUIActions.setQueueErrorMessage('First error');
+            const { rerender, unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
+            });
+            act(() => {
+                capturedUIActions.setQueueErrorMessage('First error');
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('First error');
-            vi.advanceTimersByTime(1500);
-            capturedUIActions.setQueueErrorMessage('Second error');
+            act(() => {
+                vi.advanceTimersByTime(1500);
+            });
+            act(() => {
+                capturedUIActions.setQueueErrorMessage('Second error');
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('Second error');
-            vi.advanceTimersByTime(2000);
+            act(() => {
+                vi.advanceTimersByTime(2000);
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('Second error');
             // 5. Advance time past the 3 second timeout from the second message
-            vi.advanceTimersByTime(1000);
+            act(() => {
+                vi.advanceTimersByTime(1000);
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBeNull();
+            unmount();
         });
     });
     describe('Terminal Height Calculation', () => {
         const mockedMeasureElement = measureElement;
         const mockedUseTerminalSize = useTerminalSize;
-        it('should prevent terminal height from being less than 1', () => {
+        it('should prevent terminal height from being less than 1', async () => {
             const resizePtySpy = vi.spyOn(ShellExecutionService, 'resizePty');
             // Arrange: Simulate a small terminal and a large footer
             mockedUseTerminalSize.mockReturnValue({ columns: 80, rows: 5 });
@@ -705,61 +797,55 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
                 activePtyId: 'some-id',
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert: The shell should be resized to a minimum height of 1, not a negative number.
             // The old code would have tried to set a negative height.
             expect(resizePtySpy).toHaveBeenCalled();
             const lastCall = resizePtySpy.mock.calls[resizePtySpy.mock.calls.length - 1];
             // Check the height argument specifically
             expect(lastCall[2]).toBe(1);
+            unmount();
         });
     });
-    describe('Keyboard Input Handling', () => {
-        it('should block quit command during authentication', () => {
-            mockedUseAuthCommand.mockReturnValue({
-                authState: 'unauthenticated',
-                setAuthState: vi.fn(),
-                authError: null,
-                onAuthError: vi.fn(),
-            });
-            const mockHandleSlashCommand = vi.fn();
-            mockedUseSlashCommandProcessor.mockReturnValue({
-                handleSlashCommand: mockHandleSlashCommand,
-                slashCommands: [],
-                pendingHistoryItems: [],
-                commandContext: {},
-                shellConfirmationRequest: null,
-                confirmationRequest: null,
-            });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
-        });
-        it('should prevent exit command when text buffer has content', () => {
-            mockedUseTextBuffer.mockReturnValue({
-                text: 'some user input',
-                setText: vi.fn(),
-            });
-            const mockHandleSlashCommand = vi.fn();
-            mockedUseSlashCommandProcessor.mockReturnValue({
-                handleSlashCommand: mockHandleSlashCommand,
-                slashCommands: [],
-                pendingHistoryItems: [],
-                commandContext: {},
-                shellConfirmationRequest: null,
-                confirmationRequest: null,
+    describe('Keyboard Input Handling (CTRL+C / CTRL+D)', () => {
+        let handleGlobalKeypress;
+        let mockHandleSlashCommand;
+        let mockCancelOngoingRequest;
+        let rerender;
+        let unmount;
+        // Helper function to reduce boilerplate in tests
+        const setupKeypressTest = async () => {
+            const renderResult = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
-        });
-        it('should require double Ctrl+C to exit when dialogs are open', () => {
-            vi.useFakeTimers();
-            mockedUseThemeCommand.mockReturnValue({
-                isThemeDialogOpen: true,
-                openThemeDialog: vi.fn(),
-                handleThemeSelect: vi.fn(),
-                handleThemeHighlight: vi.fn(),
+            rerender = () => renderResult.rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            unmount = renderResult.unmount;
+        };
+        const pressKey = (key, times = 1) => {
+            for (let i = 0; i < times; i++) {
+                act(() => {
+                    handleGlobalKeypress({
+                        name: 'c',
+                        ctrl: false,
+                        meta: false,
+                        shift: false,
+                        ...key,
+                    });
+                });
+                rerender();
+            }
+        };
+        beforeEach(() => {
+            // Capture the keypress handler from the AppContainer
+            mockedUseKeypress.mockImplementation((callback) => {
+                handleGlobalKeypress = callback;
             });
-            const mockHandleSlashCommand = vi.fn();
+            // Mock slash command handler
+            mockHandleSlashCommand = vi.fn();
             mockedUseSlashCommandProcessor.mockReturnValue({
                 handleSlashCommand: mockHandleSlashCommand,
                 slashCommands: [],
@@ -768,72 +854,344 @@ describe('AppContainer State Management', () => {
                 shellConfirmationRequest: null,
                 confirmationRequest: null,
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
-            vi.useRealTimers();
-        });
-        it('should cancel ongoing request on first Ctrl+C', () => {
-            const mockCancelOngoingRequest = vi.fn();
+            // Mock request cancellation
+            mockCancelOngoingRequest = vi.fn();
             mockedUseGeminiStream.mockReturnValue({
-                streamingState: 'responding',
+                streamingState: 'idle',
                 submitQuery: vi.fn(),
                 initError: null,
                 pendingHistoryItems: [],
                 thought: null,
                 cancelOngoingRequest: mockCancelOngoingRequest,
             });
-            const mockHandleSlashCommand = vi.fn();
-            mockedUseSlashCommandProcessor.mockReturnValue({
-                handleSlashCommand: mockHandleSlashCommand,
-                slashCommands: [],
-                pendingHistoryItems: [],
-                commandContext: {},
-                shellConfirmationRequest: null,
-                confirmationRequest: null,
+            // Default empty text buffer
+            mockedUseTextBuffer.mockReturnValue({
+                text: '',
+                setText: vi.fn(),
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
-        });
-        it('should reset Ctrl+C state after timeout', () => {
             vi.useFakeTimers();
-            const mockHandleSlashCommand = vi.fn();
-            mockedUseSlashCommandProcessor.mockReturnValue({
-                handleSlashCommand: mockHandleSlashCommand,
-                slashCommands: [],
-                pendingHistoryItems: [],
-                commandContext: {},
-                shellConfirmationRequest: null,
-                confirmationRequest: null,
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        describe('CTRL+C', () => {
+            it('should cancel ongoing request on first press', async () => {
+                mockedUseGeminiStream.mockReturnValue({
+                    streamingState: 'responding',
+                    submitQuery: vi.fn(),
+                    initError: null,
+                    pendingHistoryItems: [],
+                    thought: null,
+                    cancelOngoingRequest: mockCancelOngoingRequest,
+                });
+                await setupKeypressTest();
+                pressKey({ name: 'c', ctrl: true });
+                expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(1);
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
+            });
+            it('should quit on second press', async () => {
+                await setupKeypressTest();
+                pressKey({ name: 'c', ctrl: true }, 2);
+                expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(2);
+                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit');
+                unmount();
+            });
+            it('should reset press count after a timeout', async () => {
+                await setupKeypressTest();
+                pressKey({ name: 'c', ctrl: true });
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                // Advance timer past the reset threshold
+                act(() => {
+                    vi.advanceTimersByTime(1001);
+                });
+                pressKey({ name: 'c', ctrl: true });
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
+            });
+        });
+        describe('CTRL+D', () => {
+            it('should do nothing if text buffer is not empty', async () => {
+                mockedUseTextBuffer.mockReturnValue({
+                    text: 'some text',
+                    setText: vi.fn(),
+                });
+                await setupKeypressTest();
+                pressKey({ name: 'd', ctrl: true }, 2);
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
+            });
+            it('should quit on second press if buffer is empty', async () => {
+                await setupKeypressTest();
+                pressKey({ name: 'd', ctrl: true }, 2);
+                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit');
+                unmount();
+            });
+            it('should reset press count after a timeout', async () => {
+                await setupKeypressTest();
+                pressKey({ name: 'd', ctrl: true });
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                // Advance timer past the reset threshold
+                act(() => {
+                    vi.advanceTimersByTime(1001);
+                });
+                pressKey({ name: 'd', ctrl: true });
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
+            });
+        });
+    });
+    describe('Copy Mode (CTRL+S)', () => {
+        let handleGlobalKeypress;
+        let rerender;
+        let unmount;
+        const setupCopyModeTest = async (isAlternateMode = false) => {
+            // Update settings for this test run
+            const testSettings = {
+                ...mockSettings,
+                merged: {
+                    ...mockSettings.merged,
+                    ui: {
+                        ...mockSettings.merged.ui,
+                        useAlternateBuffer: isAlternateMode,
+                    },
+                },
+            };
+            const renderResult = render(_jsx(AppContainer, { config: mockConfig, settings: testSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
+            });
+            rerender = () => renderResult.rerender(_jsx(AppContainer, { config: mockConfig, settings: testSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            unmount = renderResult.unmount;
+        };
+        beforeEach(() => {
+            mockStdout.write.mockClear();
+            mockedUseKeypress.mockImplementation((callback) => {
+                handleGlobalKeypress = callback;
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
-            vi.advanceTimersByTime(1001);
-            expect(mockHandleSlashCommand).not.toHaveBeenCalledWith('/quit');
+            vi.useFakeTimers();
+        });
+        afterEach(() => {
             vi.useRealTimers();
         });
+        describe.each([
+            {
+                isAlternateMode: false,
+                shouldEnable: false,
+                modeName: 'Normal Mode',
+            },
+            {
+                isAlternateMode: true,
+                shouldEnable: true,
+                modeName: 'Alternate Buffer Mode',
+            },
+        ])('$modeName', ({ isAlternateMode, shouldEnable }) => {
+            it(`should ${shouldEnable ? 'toggle' : 'NOT toggle'} mouse off when Ctrl+S is pressed`, async () => {
+                await setupCopyModeTest(isAlternateMode);
+                mockStdout.write.mockClear(); // Clear initial enable call
+                act(() => {
+                    handleGlobalKeypress({
+                        name: 's',
+                        ctrl: true,
+                        meta: false,
+                        shift: false,
+                        paste: false,
+                        sequence: '\x13',
+                    });
+                });
+                rerender();
+                if (shouldEnable) {
+                    expect(disableMouseEvents).toHaveBeenCalled();
+                }
+                else {
+                    expect(disableMouseEvents).not.toHaveBeenCalled();
+                }
+                unmount();
+            });
+            if (shouldEnable) {
+                it('should toggle mouse back on when Ctrl+S is pressed again', async () => {
+                    await setupCopyModeTest(isAlternateMode);
+                    mockStdout.write.mockClear();
+                    // Turn it on (disable mouse)
+                    act(() => {
+                        handleGlobalKeypress({
+                            name: 's',
+                            ctrl: true,
+                            meta: false,
+                            shift: false,
+                            paste: false,
+                            sequence: '\x13',
+                        });
+                    });
+                    rerender();
+                    expect(disableMouseEvents).toHaveBeenCalled();
+                    // Turn it off (enable mouse)
+                    act(() => {
+                        handleGlobalKeypress({
+                            name: 'any', // Any key should exit copy mode
+                            ctrl: false,
+                            meta: false,
+                            shift: false,
+                            paste: false,
+                            sequence: 'a',
+                        });
+                    });
+                    rerender();
+                    expect(enableMouseEvents).toHaveBeenCalled();
+                    unmount();
+                });
+                it('should exit copy mode on any key press', async () => {
+                    await setupCopyModeTest(isAlternateMode);
+                    // Enter copy mode
+                    act(() => {
+                        handleGlobalKeypress({
+                            name: 's',
+                            ctrl: true,
+                            meta: false,
+                            shift: false,
+                            paste: false,
+                            sequence: '\x13',
+                        });
+                    });
+                    rerender();
+                    mockStdout.write.mockClear();
+                    // Press any other key
+                    act(() => {
+                        handleGlobalKeypress({
+                            name: 'a',
+                            ctrl: false,
+                            meta: false,
+                            shift: false,
+                            paste: false,
+                            sequence: 'a',
+                        });
+                    });
+                    rerender();
+                    // Should have re-enabled mouse
+                    expect(enableMouseEvents).toHaveBeenCalled();
+                    unmount();
+                });
+            }
+        });
     });
     describe('Model Dialog Integration', () => {
-        it('should provide isModelDialogOpen in the UIStateContext', () => {
+        it('should provide isModelDialogOpen in the UIStateContext', async () => {
             mockedUseModelCommand.mockReturnValue({
                 isModelDialogOpen: true,
                 openModelDialog: vi.fn(),
                 closeModelDialog: vi.fn(),
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             expect(capturedUIState.isModelDialogOpen).toBe(true);
+            unmount();
         });
-        it('should provide model dialog actions in the UIActionsContext', () => {
+        it('should provide model dialog actions in the UIActionsContext', async () => {
             const mockCloseModelDialog = vi.fn();
             mockedUseModelCommand.mockReturnValue({
                 isModelDialogOpen: false,
                 openModelDialog: vi.fn(),
                 closeModelDialog: mockCloseModelDialog,
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Verify that the actions are correctly passed through context
-            capturedUIActions.closeModelDialog();
+            act(() => {
+                capturedUIActions.closeModelDialog();
+            });
             expect(mockCloseModelDialog).toHaveBeenCalled();
+            unmount();
+        });
+    });
+    describe('CoreEvents Integration', () => {
+        it('subscribes to UserFeedback and drains backlog on mount', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            expect(mockCoreEvents.on).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
+            expect(mockCoreEvents.drainFeedbackBacklog).toHaveBeenCalledTimes(1);
+            unmount();
+        });
+        it('unsubscribes from UserFeedback on unmount', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
+            expect(mockCoreEvents.off).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
+        });
+        it('adds history item when UserFeedback event is received', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            // Get the registered handler
+            const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.UserFeedback)?.[1];
+            expect(handler).toBeDefined();
+            // Simulate an event
+            const payload = {
+                severity: 'error',
+                message: 'Test error message',
+            };
+            act(() => {
+                handler(payload);
+            });
+            expect(mockedUseHistory().addItem).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'error',
+                text: 'Test error message',
+            }), expect.any(Number));
+            unmount();
+        });
+        it('updates currentModel when ModelChanged event is received', async () => {
+            // Arrange: Mock initial model
+            vi.spyOn(mockConfig, 'getModel').mockReturnValue('initial-model');
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            // Verify initial model
+            await act(async () => {
+                await vi.waitFor(() => {
+                    expect(capturedUIState?.currentModel).toBe('initial-model');
+                });
+            });
+            // Get the registered handler for ModelChanged
+            const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.ModelChanged)?.[1];
+            expect(handler).toBeDefined();
+            // Act: Simulate ModelChanged event
+            act(() => {
+                handler({ model: 'new-model' });
+            });
+            // Assert: Verify model is updated
+            expect(capturedUIState.currentModel).toBe('new-model');
+            unmount();
+        });
+    });
+    describe('Shell Interaction', () => {
+        it('should not crash if resizing the pty fails', async () => {
+            const resizePtySpy = vi
+                .spyOn(ShellExecutionService, 'resizePty')
+                .mockImplementation(() => {
+                throw new Error('Cannot resize a pty that has already exited');
+            });
+            mockedUseGeminiStream.mockReturnValue({
+                streamingState: 'idle',
+                submitQuery: vi.fn(),
+                initError: null,
+                pendingHistoryItems: [],
+                thought: null,
+                cancelOngoingRequest: vi.fn(),
+                activePtyId: 'some-pty-id', // Make sure activePtyId is set
+            });
+            // The main assertion is that the render does not throw.
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            expect(resizePtySpy).toHaveBeenCalled();
+            unmount();
         });
     });
 });