@machina.ai/cell-cli 1.64.0-rc2 → 1.66.0-rc1

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

@@ -170,6 +170,7 @@ vi.mock('../utils/events.js');
 vi.mock('../utils/handleAutoUpdate.js');
 vi.mock('./utils/ConsolePatcher.js');
 vi.mock('../utils/cleanup.js');
+import { appEvents, AppEvent } from '../utils/events.js';
 import { useHistory } from './hooks/useHistoryManager.js';
 import { useThemeCommand } from './hooks/useThemeCommand.js';
 import { useAuthCommand } from './auth/useAuth.js';
@@ -196,9 +197,16 @@ import { useInputHistoryStore } from './hooks/useInputHistoryStore.js';
 import { useKeypress } from './hooks/useKeypress.js';
 import * as useKeypressModule from './hooks/useKeypress.js';
 import { useSuspend } from './hooks/useSuspend.js';
+import { useTerminalSize } from './hooks/useTerminalSize.js';
 import { writeToStdout, enableMouseEvents, disableMouseEvents, } from '@google/gemini-cli-core';
 import {} from '../config/extension-manager.js';
 import { WARNING_PROMPT_DURATION_MS, EXPAND_HINT_DURATION_MS, } from './constants.js';
+// In the default inline mode, refreshStatic must only clear the visible
+// viewport. It must never emit `\x1b[3J` (Erase Saved Lines), which purges the
+// terminal's native scrollback history.
+const CLEAR_VIEWPORT = ansiEscapes.eraseScreen + ansiEscapes.cursorTo(0, 0);
+const ERASE_SCROLLBACK = '\x1b[3J';
+const getScrollbackPurgingWrites = () => mocks.mockStdout.write.mock.calls.filter((call) => String(call[0]).includes(ERASE_SCROLLBACK));
 describe('AppContainer State Management', () => {
     let mockConfig;
     let mockSettings;
@@ -238,6 +246,7 @@ describe('AppContainer State Management', () => {
     const mockedUseTerminalTheme = useTerminalTheme;
     const mockedUseShellInactivityStatus = useShellInactivityStatus;
     const mockedUseFocusState = useFocus;
+    const mockedUseTerminalSize = useTerminalSize;
     const DEFAULT_GEMINI_STREAM_MOCK = {
         streamingState: 'idle',
         submitQuery: vi.fn(),
@@ -371,6 +380,10 @@ describe('AppContainer State Management', () => {
         mockedUseSuspend.mockReturnValue({
             handleSuspend: vi.fn(),
         });
+        mockedUseTerminalSize.mockReturnValue({
+            columns: 80,
+            rows: 24,
+        });
         mockedUseHookDisplayState.mockReturnValue([]);
         mockedUseTerminalTheme.mockReturnValue(undefined);
         mockedUseShellInactivityStatus.mockReturnValue({
@@ -1700,6 +1713,51 @@ describe('AppContainer State Management', () => {
                 expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit', undefined, undefined, false);
                 unmount();
             });
+            it('should await in-flight cancelOngoingRequest promise before quitting on rapid double press', async () => {
+                let resolveCancel;
+                const cancelPromise = new Promise((resolve) => {
+                    resolveCancel = resolve;
+                });
+                mockCancelOngoingRequest.mockReturnValue(cancelPromise);
+                await setupKeypressTest();
+                pressKey('\x03', 2); // Rapid double Ctrl+C
+                expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(2);
+                // Should not have called /quit yet while cancelPromise is still pending
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                await act(async () => {
+                    resolveCancel();
+                    await cancelPromise;
+                });
+                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit', undefined, undefined, false);
+                unmount();
+            });
+            it('should bound waiting on a hanging cancelOngoingRequest to 1s via Promise.race on rapid double press', async () => {
+                mockCancelOngoingRequest.mockReturnValue(new Promise(() => { }));
+                await setupKeypressTest();
+                pressKey('\x03', 2); // Rapid double Ctrl+C
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                await act(async () => {
+                    await vi.advanceTimersByTimeAsync(1000);
+                });
+                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit', undefined, undefined, false);
+                unmount();
+            });
+            it('should safely handle rejected cancelOngoingRequest promise and still quit on rapid double press', async () => {
+                let rejectCancel;
+                const cancelPromise = new Promise((_, reject) => {
+                    rejectCancel = reject;
+                });
+                mockCancelOngoingRequest.mockReturnValue(cancelPromise);
+                await setupKeypressTest();
+                pressKey('\x03', 2); // Rapid double Ctrl+C
+                expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                await act(async () => {
+                    rejectCancel(new Error('Cancel failed'));
+                    await cancelPromise.catch(() => { });
+                });
+                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit', undefined, undefined, false);
+                unmount();
+            });
             it('should reset press count after a timeout', async () => {
                 await setupKeypressTest();
                 pressKey('\x03'); // Ctrl+C
@@ -2472,9 +2530,209 @@ describe('AppContainer State Management', () => {
             await act(async () => {
                 await new Promise((resolve) => setTimeout(resolve, 100));
             });
-            // Check that clearTerminal was NOT written to stdout
-            const clearTerminalCalls = mocks.mockStdout.write.mock.calls.filter((call) => call[0] === ansiEscapes.clearTerminal);
-            expect(clearTerminalCalls).toHaveLength(0);
+            // Check that refreshStatic did NOT clear the viewport
+            const clearViewportCalls = mocks.mockStdout.write.mock.calls.filter((call) => call[0] === CLEAR_VIEWPORT);
+            expect(clearViewportCalls).toHaveLength(0);
+            unmount();
+        });
+        it('keeps constrainHeight true when OpenDebugConsole event is triggered', async () => {
+            const { unmount } = await act(async () => renderAppContainer());
+            expect(capturedUIState).toBeTruthy();
+            expect(capturedUIState.showErrorDetails).toBe(false);
+            expect(capturedUIState.constrainHeight).toBe(true);
+            const openDebugConsoleHandler = vi
+                .mocked(appEvents.on)
+                .mock.calls.find((call) => call[0] === AppEvent.OpenDebugConsole)?.[1];
+            expect(openDebugConsoleHandler).toBeDefined();
+            act(() => {
+                openDebugConsoleHandler();
+            });
+            expect(capturedUIState.showErrorDetails).toBe(true);
+            expect(capturedUIState.constrainHeight).toBe(true);
+            unmount();
+        });
+        it('debounces refreshStatic when terminal width changes in default inline mode, and ignores height-only changes', async () => {
+            vi.useFakeTimers();
+            try {
+                vi.spyOn(mockConfig, 'getUseTerminalBuffer').mockReturnValue(false);
+                vi.spyOn(mockConfig, 'getUseAlternateBuffer').mockReturnValue(false);
+                const { rerender, unmount } = await act(async () => renderAppContainer());
+                expect(capturedUIState).toBeTruthy();
+                const initialRemountKey = capturedUIState.historyRemountKey;
+                mocks.mockStdout.write.mockClear();
+                // Initial mount should not trigger refreshStatic after 100ms
+                act(() => {
+                    vi.advanceTimersByTime(100);
+                });
+                expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
+                expect(capturedUIState.historyRemountKey).toBe(initialRemountKey);
+                // Simulate height-only resize (e.g. mobile virtual keyboard toggle)
+                mockedUseTerminalSize.mockReturnValue({ columns: 80, rows: 16 });
+                await act(async () => {
+                    rerender(getAppContainer());
+                });
+                act(() => {
+                    vi.advanceTimersByTime(100);
+                });
+                expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
+                expect(capturedUIState.historyRemountKey).toBe(initialRemountKey);
+                // Simulate rapid consecutive horizontal resizes (columns: 80 -> 70 -> 60)
+                mockedUseTerminalSize.mockReturnValue({ columns: 70, rows: 16 });
+                await act(async () => {
+                    rerender(getAppContainer());
+                });
+                act(() => {
+                    vi.advanceTimersByTime(60);
+                });
+                expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
+                // Second resize before 100ms elapses should reset the debounce timer
+                mockedUseTerminalSize.mockReturnValue({ columns: 60, rows: 16 });
+                await act(async () => {
+                    rerender(getAppContainer());
+                });
+                act(() => {
+                    vi.advanceTimersByTime(60);
+                });
+                expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
+                expect(capturedUIState.historyRemountKey).toBe(initialRemountKey);
+                // Remaining 40ms completes the 100ms debounce from the last width change
+                act(() => {
+                    vi.advanceTimersByTime(40);
+                });
+                expect(mocks.mockStdout.write).toHaveBeenCalledWith(CLEAR_VIEWPORT);
+                expect(capturedUIState.historyRemountKey).toBe(initialRemountKey + 1);
+                unmount();
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('corks stdout during horizontal resize, discards intermediate buffered writes, and wraps refreshStatic in synchronized output', async () => {
+            vi.useFakeTimers();
+            const mockStdoutWithCork = mocks.mockStdout;
+            let resizeListener;
+            const bufferedCallback = vi.fn();
+            const writableState = {
+                corked: 0,
+                length: 0,
+                writelen: 0,
+                buffered: [],
+                bufferedIndex: 0,
+            };
+            mockStdoutWithCork.columns = 80;
+            mockStdoutWithCork._writableState = writableState;
+            mockStdoutWithCork.cork = vi.fn(() => {
+                writableState.corked += 1;
+            });
+            mockStdoutWithCork.uncork = vi.fn(() => {
+                writableState.corked = Math.max(0, writableState.corked - 1);
+            });
+            mockStdoutWithCork.prependListener = vi.fn((event, cb) => {
+                if (event === 'resize') {
+                    resizeListener = cb;
+                }
+            });
+            mockStdoutWithCork.off = vi.fn();
+            try {
+                vi.spyOn(mockConfig, 'getUseTerminalBuffer').mockReturnValue(false);
+                vi.spyOn(mockConfig, 'getUseAlternateBuffer').mockReturnValue(false);
+                const { rerender, unmount } = await act(async () => renderAppContainer());
+                expect(resizeListener).toBeTypeOf('function');
+                mocks.mockStdout.write.mockClear();
+                mockStdoutWithCork.cork.mockClear();
+                mockStdoutWithCork.uncork.mockClear();
+                // Simulate horizontal resize event before Ink.resized runs
+                mockStdoutWithCork.columns = 60;
+                resizeListener();
+                expect(mockStdoutWithCork.cork).toHaveBeenCalledTimes(1);
+                expect(writableState.corked).toBe(1);
+                // Simulate intermediate buffered frame written while corked during resize drag
+                // alongside an active in-flight write at index 0 (bufferedIndex = 1, writelen = 10)
+                const inFlightCallback = vi.fn();
+                const discardedChunk = 'intermediate frame';
+                writableState.buffered.push({
+                    chunk: 'in-flight',
+                    encoding: 'utf8',
+                    callback: inFlightCallback,
+                }, {
+                    chunk: discardedChunk,
+                    encoding: 'utf8',
+                    callback: bufferedCallback,
+                });
+                writableState.bufferedIndex = 1;
+                writableState.writelen = 10;
+                writableState.length = 10 + Buffer.byteLength(discardedChunk, 'utf8');
+                mockedUseTerminalSize.mockReturnValue({ columns: 60, rows: 24 });
+                await act(async () => {
+                    rerender(getAppContainer());
+                });
+                // Advance 80ms (timer for 60 cols has 20ms left), then emit a new raw
+                // stdout resize event (columns = 50) BEFORE React commits the new size.
+                act(() => {
+                    vi.advanceTimersByTime(80);
+                });
+                mockStdoutWithCork.columns = 50;
+                resizeListener();
+                // Advancing past the original 100ms mark (20ms more) must NOT flush or
+                // uncork stdout for the stale 60-col width.
+                act(() => {
+                    vi.advanceTimersByTime(30);
+                });
+                expect(mocks.mockStdout.write).not.toHaveBeenCalled();
+                expect(mockStdoutWithCork.uncork).not.toHaveBeenCalled();
+                expect(writableState.corked).toBe(1);
+                // Now React commits the 50-col width and settles for 100ms
+                mockedUseTerminalSize.mockReturnValue({ columns: 50, rows: 24 });
+                await act(async () => {
+                    rerender(getAppContainer());
+                });
+                act(() => {
+                    vi.advanceTimersByTime(100);
+                });
+                // Intermediate buffered frame should have been discarded before the viewport clear,
+                // truncating buffered to startIndex (1) and preserving in-flight write state
+                expect(inFlightCallback).not.toHaveBeenCalled();
+                expect(bufferedCallback).toHaveBeenCalledWith(null);
+                expect(writableState.buffered).toHaveLength(1);
+                expect(writableState.bufferedIndex).toBe(1);
+                expect(writableState.length).toBe(10);
+                expect(writableState.writelen).toBe(10);
+                // The viewport clear should be wrapped in DEC Synchronized Output (\x1b[?2026h ... \x1b[?2026l) and uncorked in useLayoutEffect
+                expect(mocks.mockStdout.write).toHaveBeenNthCalledWith(1, '\x1b[?2026h');
+                expect(mocks.mockStdout.write).toHaveBeenNthCalledWith(2, CLEAR_VIEWPORT);
+                expect(mocks.mockStdout.write).toHaveBeenNthCalledWith(3, '\x1b[?2026l');
+                expect(getScrollbackPurgingWrites()).toHaveLength(0);
+                expect(mockStdoutWithCork.uncork).toHaveBeenCalledTimes(1);
+                expect(writableState.corked).toBe(0);
+                unmount();
+            }
+            finally {
+                delete mockStdoutWithCork.columns;
+                delete mockStdoutWithCork.cork;
+                delete mockStdoutWithCork.uncork;
+                delete mockStdoutWithCork.prependListener;
+                delete mockStdoutWithCork.off;
+                delete mockStdoutWithCork._writableState;
+                vi.useRealTimers();
+            }
+        });
+        it('refreshStatic clears only the viewport and preserves terminal scrollback in default inline mode', async () => {
+            vi.spyOn(mockConfig, 'getUseTerminalBuffer').mockReturnValue(false);
+            vi.spyOn(mockConfig, 'getUseAlternateBuffer').mockReturnValue(false);
+            const { unmount } = await act(async () => renderAppContainer());
+            expect(capturedUIActions).toBeTruthy();
+            const initialRemountKey = capturedUIState.historyRemountKey;
+            mocks.mockStdout.write.mockClear();
+            act(() => {
+                capturedUIActions.refreshStatic();
+            });
+            // Only the visible viewport is erased so earlier turns remain available
+            // in the terminal's native scrollback.
+            expect(mocks.mockStdout.write).toHaveBeenCalledWith(CLEAR_VIEWPORT);
+            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(ansiEscapes.clearTerminal);
+            expect(getScrollbackPurgingWrites()).toHaveLength(0);
+            // Static history is still remounted so it is re-rendered after the clear.
+            expect(capturedUIState.historyRemountKey).toBe(initialRemountKey + 1);
             unmount();
         });
     });
@@ -2517,8 +2775,8 @@ describe('AppContainer State Management', () => {
             await act(async () => capturedUIActions.handleFinalSubmit('test prompt'));
             // Should be reset
             expect(capturedUIState.constrainHeight).toBe(true);
-            // Should NOT refresh static's clearTerminal in alternate buffer
-            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(ansiEscapes.clearTerminal);
+            // Should NOT refresh static's viewport clear in alternate buffer
+            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
             unmount();
         });
     });
@@ -2730,7 +2988,7 @@ describe('AppContainer State Management', () => {
             });
             // Should remain expanded and not clear terminal
             expect(capturedUIState.constrainHeight).toBe(false);
-            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(ansiEscapes.clearTerminal);
+            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
             // Simulate Escape key to exit expanded view
             act(() => {
                 stdin.write('\x1b');
@@ -2743,6 +3001,104 @@ describe('AppContainer State Management', () => {
             });
             unmount();
         });
+        it('does not reset the hint timer when an overflowing ID is removed while others remain', async () => {
+            const { unmount } = await act(async () => renderAppContainer());
+            await waitFor(() => expect(capturedOverflowActions).toBeTruthy());
+            act(() => {
+                capturedOverflowActions.addOverflowingId('test-id-1');
+                capturedOverflowActions.addOverflowingId('test-id-2');
+            });
+            act(() => {
+                vi.advanceTimersByTime(1);
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(true);
+            });
+            // Advance half the duration
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS / 2);
+            });
+            expect(capturedUIState.showIsExpandableHint).toBe(true);
+            // Removing one overflowing ID should NOT reset the hint timer
+            act(() => {
+                capturedOverflowActions.removeOverflowingId('test-id-2');
+            });
+            act(() => {
+                vi.advanceTimersByTime(1);
+            });
+            // Advance the remaining half of the original timer
+            act(() => {
+                vi.advanceTimersByTime(EXPAND_HINT_DURATION_MS / 2 - 1);
+            });
+            await waitFor(() => {
+                expect(capturedUIState.showIsExpandableHint).toBe(false);
+            });
+            unmount();
+        });
+        it('does not clear terminal when expanding with Ctrl+O if there are no last-turn tool calls in history', async () => {
+            const { stdin, unmount } = await act(async () => renderAppContainer());
+            mocks.mockStdout.write.mockClear();
+            // Expand with Ctrl+O when history has no last-turn tool calls
+            act(() => {
+                stdin.write('\x0f');
+            });
+            expect(capturedUIState.constrainHeight).toBe(false);
+            expect(mocks.mockStdout.write).not.toHaveBeenCalledWith(CLEAR_VIEWPORT);
+            // Collapse with Ctrl+O should still refresh static and clear terminal
+            act(() => {
+                stdin.write('\x0f');
+            });
+            expect(capturedUIState.constrainHeight).toBe(true);
+            expect(mocks.mockStdout.write).toHaveBeenCalledWith(CLEAR_VIEWPORT);
+            unmount();
+        });
+        it('clears terminal when expanding with Ctrl+O if there are last-turn tool calls in history', async () => {
+            useHistory.mockReturnValue({
+                history: [
+                    { id: 1, type: 'user', text: 'run something' },
+                    {
+                        id: 2,
+                        type: 'tool_group',
+                        tools: [
+                            {
+                                callId: 'call-1',
+                                name: 'test_tool',
+                                description: 'desc',
+                                status: CoreToolCallStatus.Success,
+                                resultDisplay: 'result',
+                                confirmationDetails: undefined,
+                            },
+                        ],
+                    },
+                ],
+                addItem: vi.fn(),
+                updateItem: vi.fn(),
+                clearItems: vi.fn(),
+                loadHistory: vi.fn(),
+            });
+            const { stdin, unmount } = await act(async () => renderAppContainer());
+            mocks.mockStdout.write.mockClear();
+            act(() => {
+                stdin.write('\x0f');
+            });
+            expect(capturedUIState.constrainHeight).toBe(false);
+            expect(mocks.mockStdout.write).toHaveBeenCalledWith(CLEAR_VIEWPORT);
+            unmount();
+        });
+        it('passes pauseUpdates=true to useLoadingIndicator when expanded in standard mode', async () => {
+            const { stdin, unmount } = await act(async () => renderAppContainer());
+            expect(useLoadingIndicator).toHaveBeenLastCalledWith(expect.objectContaining({
+                pauseUpdates: false,
+            }));
+            act(() => {
+                stdin.write('\x0f');
+            });
+            expect(capturedUIState.constrainHeight).toBe(false);
+            expect(useLoadingIndicator).toHaveBeenLastCalledWith(expect.objectContaining({
+                pauseUpdates: true,
+            }));
+            unmount();
+        });
     });
     describe('Permission Handling', () => {
         it('shows permission dialog when checkPermissions returns paths', async () => {