@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

package/dist/src/gemini.test.js

@@ -5,18 +5,18 @@
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
 import { main, setupUnhandledRejectionHandler, validateDnsResolutionOrder, startInteractiveUI, getNodeMemoryArgs, } from './gemini.js';
-import { loadCliConfig, parseArguments } from './config/config.js';
+import { loadCliConfig, parseArguments, } from './config/config.js';
 import { loadSandboxConfig } from './config/sandboxConfig.js';
+import { createMockSandboxConfig } from '@google/gemini-cli-test-utils';
 import { terminalCapabilityManager } from './ui/utils/terminalCapabilityManager.js';
 import { start_sandbox } from './utils/sandbox.js';
 import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
 import os from 'node:os';
 import v8 from 'node:v8';
-import {} from './config/config.js';
 import { loadSettings } from './config/settings.js';
 import { createMockConfig, createMockSettings, } from './test-utils/mockConfig.js';
 import { appEvents, AppEvent } from './utils/events.js';
-import { debugLogger, coreEvents, AuthType, } from '@google/gemini-cli-core';
+import { WarningPriority, debugLogger, coreEvents, AuthType, } from '@google/gemini-cli-core';
 import { act } from 'react';
 import {} from './core/initializer.js';
 import { runNonInteractive } from './nonInteractiveCli.js';
@@ -38,6 +38,18 @@ const runNonInteractiveSpy = vi.hoisted(() => vi.fn());
 vi.mock('./nonInteractiveCli.js', () => ({
     runNonInteractive: runNonInteractiveSpy,
 }));
+const terminalNotificationMocks = vi.hoisted(() => ({
+    notifyViaTerminal: vi.fn().mockResolvedValue(true),
+    buildRunEventNotificationContent: vi.fn(() => ({
+        title: 'Session complete',
+        body: 'done',
+        subtitle: 'Run finished',
+    })),
+}));
+vi.mock('./utils/terminalNotifications.js', () => ({
+    notifyViaTerminal: terminalNotificationMocks.notifyViaTerminal,
+    buildRunEventNotificationContent: terminalNotificationMocks.buildRunEventNotificationContent,
+}));
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -79,6 +91,7 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
             clearInstance: vi.fn(),
         },
         coreEvents: {
+            // eslint-disable-next-line @typescript-eslint/no-misused-spread
             ...actual.coreEvents,
             emitFeedback: vi.fn(),
             emitConsoleLog: vi.fn(),
@@ -143,11 +156,20 @@ vi.mock('./ui/utils/terminalCapabilityManager.js', () => ({
 }));
 vi.mock('./config/config.js', () => ({
     loadCliConfig: vi.fn().mockImplementation(async () => createMockConfig()),
-    parseArguments: vi.fn().mockResolvedValue({}),
+    parseArguments: vi.fn().mockResolvedValue({
+        enabled: true,
+        allowedPaths: [],
+        networkAccess: false,
+    }),
     isDebugMode: vi.fn(() => false),
+    getRequestedWorktreeName: vi.fn(() => undefined),
+    getWorktreeArg: vi.fn(() => undefined),
 }));
 vi.mock('read-package-up', () => ({
     readPackageUp: vi.fn().mockResolvedValue({
+        enabled: true,
+        allowedPaths: [],
+        networkAccess: false,
         packageJson: { name: 'test-pkg', version: 'test-version' },
         path: '/fake/path/package.json',
     }),
@@ -179,6 +201,9 @@ vi.mock('./utils/relaunch.js', () => ({
 }));
 vi.mock('./config/sandboxConfig.js', () => ({
     loadSandboxConfig: vi.fn().mockResolvedValue({
+        enabled: true,
+        allowedPaths: [],
+        networkAccess: false,
         command: 'docker',
         image: 'test-image',
     }),
@@ -197,16 +222,13 @@ vi.mock('./validateNonInterActiveAuth.js', () => ({
     validateNonInteractiveAuth: vi.fn().mockResolvedValue('google'),
 }));
 describe('gemini.tsx main function', () => {
-    let originalEnvGeminiSandbox;
-    let originalEnvSandbox;
     let originalIsTTY;
     let initialUnhandledRejectionListeners = [];
     beforeEach(() => {
         // Store and clear sandbox-related env variables to ensure a consistent test environment
-        originalEnvGeminiSandbox = process.env['GEMINI_SANDBOX'];
-        originalEnvSandbox = process.env['SANDBOX'];
-        delete process.env['GEMINI_SANDBOX'];
-        delete process.env['SANDBOX'];
+        vi.stubEnv('GEMINI_SANDBOX', '');
+        vi.stubEnv('SANDBOX', '');
+        vi.stubEnv('SHPOOL_SESSION_NAME', '');
         initialUnhandledRejectionListeners =
             process.listeners('unhandledRejection');
         originalIsTTY = process.stdin.isTTY;
@@ -214,19 +236,6 @@ describe('gemini.tsx main function', () => {
         process.stdin.isTTY = true;
     });
     afterEach(() => {
-        // Restore original env variables
-        if (originalEnvGeminiSandbox !== undefined) {
-            process.env['GEMINI_SANDBOX'] = originalEnvGeminiSandbox;
-        }
-        else {
-            delete process.env['GEMINI_SANDBOX'];
-        }
-        if (originalEnvSandbox !== undefined) {
-            process.env['SANDBOX'] = originalEnvSandbox;
-        }
-        else {
-            delete process.env['SANDBOX'];
-        }
         const currentListeners = process.listeners('unhandledRejection');
         currentListeners.forEach((listener) => {
             if (!initialUnhandledRejectionListeners.includes(listener)) {
@@ -235,6 +244,7 @@ describe('gemini.tsx main function', () => {
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         process.stdin.isTTY = originalIsTTY;
+        vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
     it('should log unhandled promise rejections and open debug console on first error', async () => {
@@ -293,13 +303,27 @@ describe('initializeOutputListenersAndFlush', () => {
 describe('getNodeMemoryArgs', () => {
     let osTotalMemSpy;
     let v8GetHeapStatisticsSpy;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let originalConfig;
     beforeEach(() => {
         osTotalMemSpy = vi.spyOn(os, 'totalmem');
         v8GetHeapStatisticsSpy = vi.spyOn(v8, 'getHeapStatistics');
         delete process.env['CELL_CLI_NO_RELAUNCH'];
+        originalConfig = process.config;
+        Object.defineProperty(process, 'config', {
+            value: {
+                ...originalConfig,
+                variables: { ...originalConfig?.variables, v8_enable_sandbox: 1 },
+            },
+            configurable: true,
+        });
     });
     afterEach(() => {
         vi.restoreAllMocks();
+        Object.defineProperty(process, 'config', {
+            value: originalConfig,
+            configurable: true,
+        });
     });
     it('should return empty array if CELL_CLI_NO_RELAUNCH is set', () => {
         process.env['CELL_CLI_NO_RELAUNCH'] = 'true';
@@ -310,16 +334,21 @@ describe('getNodeMemoryArgs', () => {
         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([]);
+        // Target is 50% of 16GB = 8GB. Current is 8GB. Relaunch needed for EPT size only.
+        expect(getNodeMemoryArgs(false)).toEqual([
+            '--max-external-pointer-table-size=268435456',
+        ]);
     });
     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']);
+        // Target is 50% of 16GB = 8GB. Current is 4GB. Relaunch needed for both.
+        expect(getNodeMemoryArgs(false)).toEqual([
+            '--max-external-pointer-table-size=268435456',
+            '--max-old-space-size=8192',
+        ]);
     });
     it('should log debug info when isDebugMode is true', () => {
         const debugSpy = vi.spyOn(debugLogger, 'debug');
@@ -399,6 +428,8 @@ describe('gemini.tsx main function kitty protocol', () => {
             query: undefined,
             yolo: undefined,
             approvalMode: undefined,
+            policy: undefined,
+            adminPolicy: undefined,
             allowedMcpServerNames: undefined,
             allowedTools: undefined,
             experimentalAcp: undefined,
@@ -425,6 +456,57 @@ describe('gemini.tsx main function kitty protocol', () => {
         expect(setRawModeSpy).toHaveBeenCalledWith(true);
         expect(terminalCapabilityManager.detectCapabilities).toHaveBeenCalledTimes(1);
     });
+    it('should call process.stdin.resume when isInteractive is true to protect against implicit Node pause', async () => {
+        const resumeSpy = vi.spyOn(process.stdin, 'resume');
+        vi.mocked(loadCliConfig).mockResolvedValue(createMockConfig({
+            isInteractive: () => true,
+            getQuestion: () => '',
+            getSandbox: () => undefined,
+        }));
+        vi.mocked(loadSettings).mockReturnValue(createMockSettings({
+            merged: {
+                advanced: {},
+                security: { auth: {} },
+                ui: {},
+            },
+        }));
+        vi.mocked(parseArguments).mockResolvedValue({
+            model: undefined,
+            sandbox: undefined,
+            debug: undefined,
+            prompt: undefined,
+            promptInteractive: undefined,
+            query: undefined,
+            yolo: undefined,
+            approvalMode: undefined,
+            policy: undefined,
+            adminPolicy: undefined,
+            allowedMcpServerNames: undefined,
+            allowedTools: undefined,
+            experimentalAcp: undefined,
+            extensions: undefined,
+            listExtensions: undefined,
+            includeDirectories: undefined,
+            screenReader: undefined,
+            sessionSummary: undefined,
+            logout: undefined,
+            useWriteTodos: undefined,
+            resume: undefined,
+            listSessions: undefined,
+            deleteSession: undefined,
+            outputFormat: undefined,
+            fakeResponses: undefined,
+            recordResponses: undefined,
+            rawOutput: undefined,
+            acceptRawOutputRisk: undefined,
+            isCommand: undefined,
+        });
+        await act(async () => {
+            await main();
+        });
+        expect(resumeSpy).toHaveBeenCalledTimes(1);
+        resumeSpy.mockRestore();
+    });
     it.each([
         { flag: 'listExtensions' },
         { flag: 'listSessions' },
@@ -447,6 +529,9 @@ describe('gemini.tsx main function kitty protocol', () => {
             forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: false,
         }); // eslint-disable-line @typescript-eslint/no-explicit-any
         const mockConfig = createMockConfig({
@@ -506,6 +591,9 @@ describe('gemini.tsx main function kitty protocol', () => {
             throw new MockProcessExitError(code);
         });
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: false,
         }); // eslint-disable-line @typescript-eslint/no-explicit-any
         vi.mocked(loadSettings).mockReturnValue(createMockSettings({
@@ -521,13 +609,13 @@ describe('gemini.tsx main function kitty protocol', () => {
         const mockConfig = createMockConfig({
             isInteractive: () => false,
             getQuestion: () => '',
-            getSandbox: () => ({ command: 'docker', image: 'test-image' }),
+            getSandbox: () => createMockSandboxConfig({ command: 'docker', image: 'test-image' }),
         });
         vi.mocked(loadCliConfig).mockResolvedValue(mockConfig);
-        vi.mocked(loadSandboxConfig).mockResolvedValue({
+        vi.mocked(loadSandboxConfig).mockResolvedValue(createMockSandboxConfig({
             command: 'docker',
             image: 'test-image',
-        });
+        }));
         process.env['GEMINI_API_KEY'] = 'test-key';
         try {
             await main();
@@ -564,6 +652,9 @@ describe('gemini.tsx main function kitty protocol', () => {
             forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: false,
         }); // eslint-disable-line @typescript-eslint/no-explicit-any
         vi.mocked(loadCliConfig).mockResolvedValue(createMockConfig({
@@ -606,6 +697,9 @@ describe('gemini.tsx main function kitty protocol', () => {
             forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: false,
             resume: 'session-id',
         }); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -626,6 +720,45 @@ describe('gemini.tsx main function kitty protocol', () => {
         processExitSpy.mockRestore();
         emitFeedbackSpy.mockRestore();
     });
+    it('should start normally with a warning when no sessions found for resume', async () => {
+        const { SessionSelector, SessionError } = await import('./utils/sessionUtils.js');
+        vi.mocked(SessionSelector).mockImplementation(() => ({
+            resolveSession: vi
+                .fn()
+                .mockRejectedValue(SessionError.noSessionsFound()),
+        }));
+        const processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new MockProcessExitError(code);
+        });
+        const emitFeedbackSpy = vi.spyOn(coreEvents, 'emitFeedback');
+        vi.mocked(loadSettings).mockReturnValue(createMockSettings({
+            merged: { advanced: {}, security: { auth: {} }, ui: { theme: 'test' } },
+            workspace: { settings: {} },
+            setValue: vi.fn(),
+            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+        }));
+        vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
+            promptInteractive: false,
+            resume: 'latest',
+        });
+        vi.mocked(loadCliConfig).mockResolvedValue(createMockConfig({
+            isInteractive: () => true,
+            getQuestion: () => '',
+            getSandbox: () => undefined,
+        }));
+        await main();
+        // Should NOT have crashed
+        expect(processExitSpy).not.toHaveBeenCalled();
+        // Should NOT have emitted a feedback error
+        expect(emitFeedbackSpy).not.toHaveBeenCalledWith('error', expect.stringContaining('Error resuming session'));
+        processExitSpy.mockRestore();
+        emitFeedbackSpy.mockRestore();
+    });
     it.skip('should log error when cleanupExpiredSessions fails', async () => {
         const { cleanupExpiredSessions } = await import('./utils/sessionCleanup.js');
         vi.mocked(cleanupExpiredSessions).mockRejectedValue(new Error('Cleanup failed'));
@@ -644,6 +777,9 @@ describe('gemini.tsx main function kitty protocol', () => {
             forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: false,
         }); // eslint-disable-line @typescript-eslint/no-explicit-any
         vi.mocked(loadCliConfig).mockResolvedValue(createMockConfig({
@@ -681,6 +817,9 @@ describe('gemini.tsx main function kitty protocol', () => {
             forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: false,
         }); // eslint-disable-line @typescript-eslint/no-explicit-any
         vi.mocked(loadCliConfig).mockResolvedValue(createMockConfig({
@@ -709,6 +848,8 @@ describe('gemini.tsx main function kitty protocol', () => {
         expect(runNonInteractive).toHaveBeenCalled();
         const callArgs = vi.mocked(runNonInteractive).mock.calls[0][0];
         expect(callArgs.input).toBe('stdin-data\n\ntest-question');
+        expect(terminalNotificationMocks.buildRunEventNotificationContent).not.toHaveBeenCalled();
+        expect(terminalNotificationMocks.notifyViaTerminal).not.toHaveBeenCalled();
         expect(processExitSpy).toHaveBeenCalledWith(0);
         processExitSpy.mockRestore();
     });
@@ -743,6 +884,9 @@ describe('gemini.tsx main function exit codes', () => {
             merged: { security: { auth: {} }, ui: {} },
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             promptInteractive: true,
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -758,10 +902,10 @@ describe('gemini.tsx main function exit codes', () => {
     });
     it('should exit with 41 for auth failure during sandbox setup', async () => {
         vi.stubEnv('SANDBOX', '');
-        vi.mocked(loadSandboxConfig).mockResolvedValue({
+        vi.mocked(loadSandboxConfig).mockResolvedValue(createMockSandboxConfig({
             command: 'docker',
             image: 'test-image',
-        });
+        }));
         vi.mocked(loadCliConfig).mockResolvedValue(createMockConfig({
             refreshAuth: vi.fn().mockRejectedValue(new Error('Auth failed')),
             getRemoteAdminSettings: vi.fn().mockReturnValue(undefined),
@@ -792,15 +936,22 @@ describe('gemini.tsx main function exit codes', () => {
             merged: { security: { auth: {} }, ui: {} },
         }));
         vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             resume: 'invalid-session',
         });
-        vi.mock('./utils/sessionUtils.js', () => ({
-            SessionSelector: vi.fn().mockImplementation(() => ({
-                resolveSession: vi
-                    .fn()
-                    .mockRejectedValue(new Error('Session not found')),
-            })),
-        }));
+        vi.mock('./utils/sessionUtils.js', async (importOriginal) => {
+            const original = await importOriginal();
+            return {
+                ...original,
+                SessionSelector: vi.fn().mockImplementation(() => ({
+                    resolveSession: vi
+                        .fn()
+                        .mockRejectedValue(new Error('Session not found')),
+                })),
+            };
+        });
         process.env['GEMINI_API_KEY'] = 'test-key';
         try {
             await main();
@@ -823,7 +974,11 @@ describe('gemini.tsx main function exit codes', () => {
         vi.mocked(loadSettings).mockReturnValue(createMockSettings({
             merged: { security: { auth: {} }, ui: {} },
         }));
-        vi.mocked(parseArguments).mockResolvedValue({});
+        vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
+        });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         process.stdin.isTTY = true;
         process.env['GEMINI_API_KEY'] = 'test-key';
@@ -851,7 +1006,11 @@ describe('gemini.tsx main function exit codes', () => {
         vi.mocked(loadSettings).mockReturnValue(createMockSettings({
             merged: { security: { auth: { selectedType: undefined } }, ui: {} },
         }));
-        vi.mocked(parseArguments).mockResolvedValue({});
+        vi.mocked(parseArguments).mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
+        });
         runNonInteractiveSpy.mockImplementation(() => Promise.resolve());
         const processExitSpy = vi
             .spyOn(process, 'exit')
@@ -909,7 +1068,12 @@ describe('project hooks loading based on trust', () => {
         const configModule = await import('./config/config.js');
         loadCliConfig = vi.mocked(configModule.loadCliConfig);
         parseArguments = vi.mocked(configModule.parseArguments);
-        parseArguments.mockResolvedValue({ startupMessages: [] });
+        parseArguments.mockResolvedValue({
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
+            startupMessages: [],
+        });
         const settingsModule = await import('./config/settings.js');
         loadSettings = vi.mocked(settingsModule.loadSettings);
         vi.clearAllMocks();
@@ -964,6 +1128,7 @@ describe('startInteractiveUI', () => {
         getProjectRoot: () => '/root',
         getScreenReader: () => false,
         getDebugMode: () => false,
+        getUseAlternateBuffer: () => true,
     });
     const mockSettings = {
         merged: {
@@ -977,10 +1142,13 @@ describe('startInteractiveUI', () => {
             },
         },
     };
-    const mockStartupWarnings = ['warning1'];
+    const mockStartupWarnings = [
+        { id: 'w1', message: 'warning1', priority: WarningPriority.High },
+    ];
     const mockWorkspaceRoot = '/root';
     const mockInitializationResult = {
         authError: null,
+        accountSuspensionInfo: null,
         themeError: null,
         shouldOpenAuthDialog: false,
         geminiMdFileCount: 0,
@@ -994,8 +1162,14 @@ describe('startInteractiveUI', () => {
         runExitCleanup: vi.fn(),
         registerSyncCleanup: vi.fn(),
         registerTelemetryConfig: vi.fn(),
+        setupSignalHandlers: vi.fn(),
+        setupTtyCheck: vi.fn(() => vi.fn()),
     }));
+    beforeEach(() => {
+        vi.stubEnv('SHPOOL_SESSION_NAME', '');
+    });
     afterEach(() => {
+        vi.unstubAllEnvs();
         vi.restoreAllMocks();
     });
     async function startTestInteractiveUI(config, settings, startupWarnings, workspaceRoot, resumedSessionData, initializationResult) {
@@ -1039,7 +1213,8 @@ describe('startInteractiveUI', () => {
         await startTestInteractiveUI(mockConfig, mockSettings, mockStartupWarnings, mockWorkspaceRoot, undefined, mockInitializationResult);
         // Verify all startup tasks were called
         expect(getVersion).toHaveBeenCalledTimes(1);
-        expect(registerCleanup).toHaveBeenCalledTimes(3);
+        // 5 cleanups: mouseEvents, consolePatcher, lineWrapping, instance.unmount, and TTY check
+        expect(registerCleanup).toHaveBeenCalledTimes(5);
         // Verify cleanup handler is registered with unmount function
         const cleanupFn = vi.mocked(registerCleanup).mock.calls[0][0];
         expect(typeof cleanupFn).toBe('function');
@@ -1077,6 +1252,7 @@ describe('startInteractiveUI', () => {
             .spyOn(process.stdout, 'write')
             .mockImplementation(() => true);
         const mockConfigWithScreenReader = {
+            // eslint-disable-next-line @typescript-eslint/no-misused-spread
             ...mockConfig,
             getScreenReader: () => screenReader,
         };