@machina.ai/cell-cli 1.16.0-rc2 → 1.19.4-rc1

package/dist/src/gemini.test.js

@@ -4,10 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { main, setupUnhandledRejectionHandler, validateDnsResolutionOrder, startInteractiveUI, } from './gemini.js';
+import { main, setupUnhandledRejectionHandler, validateDnsResolutionOrder, startInteractiveUI, getNodeMemoryArgs, } from './gemini.js';
+import os from 'node:os';
+import v8 from 'node:v8';
 import {} from './config/settings.js';
 import { appEvents, AppEvent } from './utils/events.js';
-import {} from '@google/gemini-cli-core';
+import { debugLogger, } from '@google/gemini-cli-core';
 import { act } from 'react';
 import {} from './core/initializer.js';
 const performance = vi.hoisted(() => ({
@@ -19,15 +21,47 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     return {
         ...actual,
         recordSlowRender: vi.fn(),
+        writeToStdout: vi.fn((...args) => process.stdout.write(...args)),
+        patchStdio: vi.fn(() => () => { }),
+        createInkStdio: vi.fn(() => ({
+            stdout: {
+                write: vi.fn((...args) => process.stdout.write(...args)),
+                columns: 80,
+                rows: 24,
+                on: vi.fn(),
+                removeListener: vi.fn(),
+            },
+            stderr: {
+                write: vi.fn(),
+            },
+        })),
+        enableMouseEvents: vi.fn(),
+        disableMouseEvents: vi.fn(),
+        enterAlternateScreen: vi.fn(),
+        disableLineWrapping: vi.fn(),
     };
 });
 vi.mock('ink', async (importOriginal) => {
     const actual = await importOriginal();
     return {
         ...actual,
-        // Mock here so we can spyOn the render function. ink uses ESM which doesn't
-        // allow us to spyOn it directly.
-        render: vi.fn((_node, options) => actual.render(_node, options)),
+        render: vi.fn((_node, options) => {
+            if (options.alternateBuffer) {
+                options.stdout.write('\x1b[?7l');
+            }
+            // Simulate rendering time for recordSlowRender test
+            const start = performance.now();
+            const end = performance.now();
+            if (options.onRender) {
+                options.onRender({ renderTime: end - start });
+            }
+            return {
+                unmount: vi.fn(),
+                rerender: vi.fn(),
+                cleanup: vi.fn(),
+                waitUntilExit: vi.fn(),
+            };
+        }),
     };
 });
 // Custom error to identify mock process.exit calls
@@ -94,10 +128,17 @@ vi.mock('./utils/sandbox.js', () => ({
 }));
 vi.mock('./utils/relaunch.js', () => ({
     relaunchAppInChildProcess: vi.fn(),
+    relaunchOnExitCode: vi.fn(),
 }));
 vi.mock('./config/sandboxConfig.js', () => ({
     loadSandboxConfig: vi.fn(),
 }));
+vi.mock('./ui/utils/mouse.js', () => ({
+    enableMouseEvents: vi.fn(),
+    disableMouseEvents: vi.fn(),
+    parseMouseEvent: vi.fn(),
+    isIncompleteMouseSequence: vi.fn(),
+}));
 describe('gemini.tsx main function', () => {
     let originalEnvGeminiSandbox;
     let originalEnvSandbox;
@@ -218,6 +259,7 @@ describe('gemini.tsx main function', () => {
             throw new MockProcessExitError(code);
         });
         const appEventsMock = vi.mocked(appEvents);
+        const debugLoggerErrorSpy = vi.spyOn(debugLogger, 'error');
         const rejectionError = new Error('Test unhandled rejection');
         setupUnhandledRejectionHandler();
         // Simulate an unhandled rejection.
@@ -227,8 +269,8 @@ describe('gemini.tsx main function', () => {
         // We need to wait for the rejection handler to be called.
         await new Promise(process.nextTick);
         expect(appEventsMock.emit).toHaveBeenCalledWith(AppEvent.OpenDebugConsole);
-        expect(appEventsMock.emit).toHaveBeenCalledWith(AppEvent.LogError, expect.stringContaining('Unhandled Promise Rejection'));
-        expect(appEventsMock.emit).toHaveBeenCalledWith(AppEvent.LogError, expect.stringContaining('Please file a bug report using the /bug tool.'));
+        expect(debugLoggerErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Unhandled Promise Rejection'));
+        expect(debugLoggerErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Please file a bug report using the /bug tool.'));
         // Simulate a second rejection
         const secondRejectionError = new Error('Second test unhandled rejection');
         process.emit('unhandledRejection', secondRejectionError, Promise.resolve());
@@ -240,6 +282,71 @@ describe('gemini.tsx main function', () => {
         processExitSpy.mockRestore();
     });
 });
+describe('setWindowTitle', () => {
+    it('should set window title when hideWindowTitle is false', async () => {
+        // setWindowTitle is not exported, but we can test its effect if we had a way to call it.
+        // Since we can't easily call it directly without exporting it, we skip direct testing
+        // and rely on startInteractiveUI tests which call it.
+    });
+});
+describe('initializeOutputListenersAndFlush', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should flush backlogs and setup listeners if no listeners exist', async () => {
+        const { coreEvents } = await import('@google/gemini-cli-core');
+        const { initializeOutputListenersAndFlush } = await import('./gemini.js');
+        // Mock listenerCount to return 0
+        vi.spyOn(coreEvents, 'listenerCount').mockReturnValue(0);
+        const drainSpy = vi.spyOn(coreEvents, 'drainBacklogs');
+        initializeOutputListenersAndFlush();
+        expect(drainSpy).toHaveBeenCalled();
+        // We can't easily check if listeners were added without access to the internal state of coreEvents,
+        // but we can verify that drainBacklogs was called.
+    });
+});
+describe('getNodeMemoryArgs', () => {
+    let osTotalMemSpy;
+    let v8GetHeapStatisticsSpy;
+    beforeEach(() => {
+        osTotalMemSpy = vi.spyOn(os, 'totalmem');
+        v8GetHeapStatisticsSpy = vi.spyOn(v8, 'getHeapStatistics');
+        delete process.env['CELL_CLI_NO_RELAUNCH'];
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should return empty array if CELL_CLI_NO_RELAUNCH is set', () => {
+        process.env['CELL_CLI_NO_RELAUNCH'] = 'true';
+        expect(getNodeMemoryArgs(false)).toEqual([]);
+    });
+    it('should return empty array if current heap limit is sufficient', () => {
+        osTotalMemSpy.mockReturnValue(16 * 1024 * 1024 * 1024); // 16GB
+        v8GetHeapStatisticsSpy.mockReturnValue({
+            heap_size_limit: 8 * 1024 * 1024 * 1024, // 8GB
+        });
+        // Target is 50% of 16GB = 8GB. Current is 8GB. No relaunch needed.
+        expect(getNodeMemoryArgs(false)).toEqual([]);
+    });
+    it('should return memory args if current heap limit is insufficient', () => {
+        osTotalMemSpy.mockReturnValue(16 * 1024 * 1024 * 1024); // 16GB
+        v8GetHeapStatisticsSpy.mockReturnValue({
+            heap_size_limit: 4 * 1024 * 1024 * 1024, // 4GB
+        });
+        // Target is 50% of 16GB = 8GB. Current is 4GB. Relaunch needed.
+        expect(getNodeMemoryArgs(false)).toEqual(['--max-old-space-size=8192']);
+    });
+    it('should log debug info when isDebugMode is true', () => {
+        const debugSpy = vi.spyOn(debugLogger, 'debug');
+        osTotalMemSpy.mockReturnValue(16 * 1024 * 1024 * 1024);
+        v8GetHeapStatisticsSpy.mockReturnValue({
+            heap_size_limit: 4 * 1024 * 1024 * 1024,
+        });
+        getNodeMemoryArgs(true);
+        expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('Current heap size'));
+        expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('Need to relaunch with more memory'));
+    });
+});
 describe('gemini.tsx main function kitty protocol', () => {
     let originalEnvNoRelaunch;
     let setRawModeSpy;
@@ -360,30 +467,573 @@ describe('gemini.tsx main function kitty protocol', () => {
         expect(setRawModeSpy).toHaveBeenCalledWith(true);
         expect(detectAndEnableKittyProtocol).toHaveBeenCalledTimes(1);
     });
+    it.each([
+        { flag: 'listExtensions' },
+        { flag: 'listSessions' },
+        { flag: 'deleteSession', value: 'session-id' },
+    ])('should handle --$flag flag', async ({ flag, value }) => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const { listSessions, deleteSession } = await import('./utils/sessions.js');
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: {
+                advanced: {},
+                security: { auth: {} },
+                ui: {},
+            },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const mockConfig = {
+            isInteractive: () => false,
+            getQuestion: () => '',
+            getSandbox: () => false,
+            getDebugMode: () => false,
+            getListExtensions: () => flag === 'listExtensions',
+            getListSessions: () => flag === 'listSessions',
+            getDeleteSession: () => (flag === 'deleteSession' ? value : undefined),
+            getExtensions: () => [{ name: 'ext1' }],
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+        };
+        vi.mocked(loadCliConfig).mockResolvedValue(mockConfig);
+        vi.mock('./utils/sessions.js', () => ({
+            listSessions: vi.fn(),
+            deleteSession: vi.fn(),
+        }));
+        const debugLoggerLogSpy = vi
+            .spyOn(debugLogger, 'log')
+            .mockImplementation(() => { });
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        if (flag === 'listExtensions') {
+            expect(debugLoggerLogSpy).toHaveBeenCalledWith(expect.stringContaining('ext1'));
+        }
+        else if (flag === 'listSessions') {
+            expect(listSessions).toHaveBeenCalledWith(mockConfig);
+        }
+        else if (flag === 'deleteSession') {
+            expect(deleteSession).toHaveBeenCalledWith(mockConfig, value);
+        }
+        expect(processExitSpy).toHaveBeenCalledWith(0);
+        processExitSpy.mockRestore();
+    });
+    it('should handle sandbox activation', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSandboxConfig } = await import('./config/sandboxConfig.js');
+        const { start_sandbox } = await import('./utils/sandbox.js');
+        const { relaunchOnExitCode } = await import('./utils/relaunch.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: {
+                advanced: {},
+                security: { auth: {} },
+                ui: {},
+            },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const mockConfig = {
+            isInteractive: () => false,
+            getQuestion: () => '',
+            getSandbox: () => true,
+            getDebugMode: () => false,
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
+            getExtensions: () => [],
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+            refreshAuth: vi.fn(),
+        };
+        vi.mocked(loadCliConfig).mockResolvedValue(mockConfig);
+        vi.mocked(loadSandboxConfig).mockResolvedValue({}); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(relaunchOnExitCode).mockImplementation(async (fn) => {
+            await fn();
+        });
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(start_sandbox).toHaveBeenCalled();
+        expect(processExitSpy).toHaveBeenCalledWith(0);
+        processExitSpy.mockRestore();
+    });
+    it('should exit with error when --prompt-interactive is used with piped input', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const core = await import('@google/gemini-cli-core');
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        const writeToStderrSpy = vi
+            .spyOn(core, 'writeToStderr')
+            .mockImplementation(() => true);
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: { advanced: {}, security: { auth: {} }, ui: {} },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: true,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => false,
+            getQuestion: () => '',
+            getSandbox: () => false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        // Mock stdin to be non-TTY
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: false,
+            configurable: true,
+        });
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(writeToStderrSpy).toHaveBeenCalledWith(expect.stringContaining('Error: The --prompt-interactive flag cannot be used'));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        processExitSpy.mockRestore();
+        writeToStderrSpy.mockRestore();
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: true,
+            configurable: true,
+        }); // Restore TTY
+    });
+    it('should log warning when theme is not found', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const { themeManager } = await import('./ui/themes/theme-manager.js');
+        const debugLoggerWarnSpy = vi
+            .spyOn(debugLogger, 'warn')
+            .mockImplementation(() => { });
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: {
+                advanced: {},
+                security: { auth: {} },
+                ui: { theme: 'non-existent-theme' },
+            },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => false,
+            getQuestion: () => 'test',
+            getSandbox: () => false,
+            getDebugMode: () => false,
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
+            getToolRegistry: vi.fn(),
+            getExtensions: () => [],
+            getModel: () => 'gemini-pro',
+            getEmbeddingModel: () => 'embedding-001',
+            getApprovalMode: () => 'default',
+            getCoreTools: () => [],
+            getTelemetryEnabled: () => false,
+            getTelemetryLogPromptsEnabled: () => false,
+            getFileFilteringRespectGitIgnore: () => true,
+            getOutputFormat: () => 'text',
+            getUsageStatisticsEnabled: () => false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.spyOn(themeManager, 'setActiveTheme').mockReturnValue(false);
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(debugLoggerWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Warning: Theme "non-existent-theme" not found.'));
+        processExitSpy.mockRestore();
+    });
+    it('should handle session selector error', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        vi.mock('./utils/sessionUtils.js', () => ({
+            SessionSelector: class {
+                resolveSession = vi
+                    .fn()
+                    .mockRejectedValue(new Error('Session not found'));
+            },
+        }));
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        const consoleErrorSpy = vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => { });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: { advanced: {}, security: { auth: {} }, ui: { theme: 'test' } },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+            resume: 'session-id',
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => true,
+            getQuestion: () => '',
+            getSandbox: () => false,
+            getDebugMode: () => false,
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
+            getToolRegistry: vi.fn(),
+            getExtensions: () => [],
+            getModel: () => 'gemini-pro',
+            getEmbeddingModel: () => 'embedding-001',
+            getApprovalMode: () => 'default',
+            getCoreTools: () => [],
+            getTelemetryEnabled: () => false,
+            getTelemetryLogPromptsEnabled: () => false,
+            getFileFilteringRespectGitIgnore: () => true,
+            getOutputFormat: () => 'text',
+            getUsageStatisticsEnabled: () => false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error resuming session: Session not found'));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        processExitSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+    });
+    it.skip('should log error when cleanupExpiredSessions fails', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const { cleanupExpiredSessions } = await import('./utils/sessionCleanup.js');
+        vi.mocked(cleanupExpiredSessions).mockRejectedValue(new Error('Cleanup failed'));
+        const debugLoggerErrorSpy = vi
+            .spyOn(debugLogger, 'error')
+            .mockImplementation(() => { });
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: { advanced: {}, security: { auth: {} }, ui: {} },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => false,
+            getQuestion: () => 'test',
+            getSandbox: () => false,
+            getDebugMode: () => false,
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
+            getToolRegistry: vi.fn(),
+            getExtensions: () => [],
+            getModel: () => 'gemini-pro',
+            getEmbeddingModel: () => 'embedding-001',
+            getApprovalMode: () => 'default',
+            getCoreTools: () => [],
+            getTelemetryEnabled: () => false,
+            getTelemetryLogPromptsEnabled: () => false,
+            getFileFilteringRespectGitIgnore: () => true,
+            getOutputFormat: () => 'text',
+            getUsageStatisticsEnabled: () => false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        // The mock is already set up at the top of the test
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(debugLoggerErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to cleanup expired sessions: Cleanup failed'));
+        expect(processExitSpy).toHaveBeenCalledWith(0); // Should not exit on cleanup failure
+        processExitSpy.mockRestore();
+    });
+    it('should handle refreshAuth failure', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const { loadSandboxConfig } = await import('./config/sandboxConfig.js');
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        const debugLoggerErrorSpy = vi
+            .spyOn(debugLogger, 'error')
+            .mockImplementation(() => { });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: {
+                advanced: {},
+                security: { auth: { selectedType: 'google' } },
+                ui: {},
+            },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadSandboxConfig).mockResolvedValue({}); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => true,
+            getQuestion: () => '',
+            getSandbox: () => false,
+            getDebugMode: () => false,
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
+            getToolRegistry: vi.fn(),
+            getExtensions: () => [],
+            getModel: () => 'gemini-pro',
+            getEmbeddingModel: () => 'embedding-001',
+            getApprovalMode: () => 'default',
+            getCoreTools: () => [],
+            getTelemetryEnabled: () => false,
+            getTelemetryLogPromptsEnabled: () => false,
+            getFileFilteringRespectGitIgnore: () => true,
+            getOutputFormat: () => 'text',
+            getUsageStatisticsEnabled: () => false,
+            refreshAuth: vi.fn().mockRejectedValue(new Error('Auth refresh failed')),
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(debugLoggerErrorSpy).toHaveBeenCalledWith('Error authenticating:', expect.any(Error));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        processExitSpy.mockRestore();
+    });
+    it('should read from stdin in non-interactive mode', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const { readStdin } = await import('./utils/readStdin.js');
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: { advanced: {}, security: { auth: {} }, ui: {} },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            errors: [],
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(parseArguments).mockResolvedValue({
+            promptInteractive: false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => false,
+            getQuestion: () => 'test-question',
+            getSandbox: () => false,
+            getDebugMode: () => false,
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            initialize: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getProjectRoot: () => '/',
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
+            getToolRegistry: vi.fn(),
+            getExtensions: () => [],
+            getModel: () => 'gemini-pro',
+            getEmbeddingModel: () => 'embedding-001',
+            getApprovalMode: () => 'default',
+            getCoreTools: () => [],
+            getTelemetryEnabled: () => false,
+            getTelemetryLogPromptsEnabled: () => false,
+            getFileFilteringRespectGitIgnore: () => true,
+            getOutputFormat: () => 'text',
+            getUsageStatisticsEnabled: () => false,
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        vi.mock('./utils/readStdin.js', () => ({
+            readStdin: vi.fn().mockResolvedValue('stdin-data'),
+        }));
+        const runNonInteractiveSpy = vi.hoisted(() => vi.fn());
+        vi.mock('./nonInteractiveCli.js', () => ({
+            runNonInteractive: runNonInteractiveSpy,
+        }));
+        runNonInteractiveSpy.mockClear();
+        vi.mock('./validateNonInterActiveAuth.js', () => ({
+            validateNonInteractiveAuth: vi.fn().mockResolvedValue({}),
+        }));
+        // Mock stdin to be non-TTY
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: false,
+            configurable: true,
+        });
+        try {
+            await main();
+        }
+        catch (e) {
+            if (!(e instanceof MockProcessExitError))
+                throw e;
+        }
+        expect(readStdin).toHaveBeenCalled();
+        // In this test setup, runNonInteractive might be called on the mocked module,
+        // but we need to ensure we are checking the correct spy instance.
+        // Since vi.mock is hoisted, runNonInteractiveSpy is defined early.
+        expect(runNonInteractiveSpy).toHaveBeenCalled();
+        const callArgs = runNonInteractiveSpy.mock.calls[0][0];
+        expect(callArgs.input).toBe('test-question');
+        expect(processExitSpy).toHaveBeenCalledWith(0);
+        processExitSpy.mockRestore();
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: true,
+            configurable: true,
+        });
+    });
 });
 describe('validateDnsResolutionOrder', () => {
-    let consoleWarnSpy;
+    let debugLoggerWarnSpy;
     beforeEach(() => {
-        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        debugLoggerWarnSpy = vi
+            .spyOn(debugLogger, 'warn')
+            .mockImplementation(() => { });
     });
     afterEach(() => {
         vi.restoreAllMocks();
     });
     it('should return "ipv4first" when the input is "ipv4first"', () => {
         expect(validateDnsResolutionOrder('ipv4first')).toBe('ipv4first');
-        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(debugLoggerWarnSpy).not.toHaveBeenCalled();
     });
     it('should return "verbatim" when the input is "verbatim"', () => {
         expect(validateDnsResolutionOrder('verbatim')).toBe('verbatim');
-        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(debugLoggerWarnSpy).not.toHaveBeenCalled();
     });
     it('should return the default "ipv4first" when the input is undefined', () => {
         expect(validateDnsResolutionOrder(undefined)).toBe('ipv4first');
-        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(debugLoggerWarnSpy).not.toHaveBeenCalled();
     });
     it('should return the default "ipv4first" and log a warning for an invalid string', () => {
         expect(validateDnsResolutionOrder('invalid-value')).toBe('ipv4first');
-        expect(consoleWarnSpy).toHaveBeenCalledExactlyOnceWith('Invalid value for dnsResolutionOrder in settings: "invalid-value". Using default "ipv4first".');
+        expect(debugLoggerWarnSpy).toHaveBeenCalledExactlyOnceWith('Invalid value for dnsResolutionOrder in settings: "invalid-value". Using default "ipv4first".');
     });
 });
 describe('startInteractiveUI', () => {
@@ -391,11 +1041,13 @@ describe('startInteractiveUI', () => {
     const mockConfig = {
         getProjectRoot: () => '/root',
         getScreenReader: () => false,
+        getDebugMode: () => false,
     };
     const mockSettings = {
         merged: {
             ui: {
                 hideWindowTitle: false,
+                useAlternateBuffer: true,
             },
         },
     };
@@ -422,6 +1074,7 @@ describe('startInteractiveUI', () => {
         cleanupCheckpoints: vi.fn(() => Promise.resolve()),
         registerCleanup: vi.fn(),
         runExitCleanup: vi.fn(),
+        registerSyncCleanup: vi.fn(),
     }));
     afterEach(() => {
         vi.restoreAllMocks();
@@ -439,16 +1092,28 @@ describe('startInteractiveUI', () => {
         expect(renderSpy).toHaveBeenCalledTimes(1);
         const [reactElement, options] = renderSpy.mock.calls[0];
         // Verify render options
-        expect(options).toEqual({
+        expect(options).toEqual(expect.objectContaining({
             alternateBuffer: true,
             exitOnCtrlC: false,
             incrementalRendering: true,
             isScreenReaderEnabled: false,
             onRender: expect.any(Function),
-        });
+            patchConsole: false,
+        }));
         // Verify React element structure is valid (but don't deep dive into JSX internals)
         expect(reactElement).toBeDefined();
     });
+    it('should enable mouse events when alternate buffer is enabled', async () => {
+        const { enableMouseEvents } = await import('@google/gemini-cli-core');
+        await startTestInteractiveUI(mockConfig, mockSettings, mockStartupWarnings, mockWorkspaceRoot, undefined, mockInitializationResult);
+        expect(enableMouseEvents).toHaveBeenCalled();
+    });
+    it('should patch console', async () => {
+        const { ConsolePatcher } = await import('./ui/utils/ConsolePatcher.js');
+        const patchSpy = vi.spyOn(ConsolePatcher.prototype, 'patch');
+        await startTestInteractiveUI(mockConfig, mockSettings, mockStartupWarnings, mockWorkspaceRoot, undefined, mockInitializationResult);
+        expect(patchSpy).toHaveBeenCalled();
+    });
     it('should perform all startup tasks in correct order', async () => {
         const { getCliVersion } = await import('./utils/version.js');
         const { checkForUpdates } = await import('./ui/utils/updateCheck.js');
@@ -456,7 +1121,7 @@ describe('startInteractiveUI', () => {
         await startTestInteractiveUI(mockConfig, mockSettings, mockStartupWarnings, mockWorkspaceRoot, undefined, mockInitializationResult);
         // Verify all startup tasks were called
         expect(getCliVersion).toHaveBeenCalledTimes(1);
-        expect(registerCleanup).toHaveBeenCalledTimes(2);
+        expect(registerCleanup).toHaveBeenCalledTimes(3);
         // Verify cleanup handler is registered with unmount function
         const cleanupFn = vi.mocked(registerCleanup).mock.calls[0][0];
         expect(typeof cleanupFn).toBe('function');