@machina.ai/cell-cli 1.19.4-rc3 → 1.20.2-rc1

package/dist/src/gemini.test.js

@@ -7,6 +7,7 @@ import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
 import { main, setupUnhandledRejectionHandler, validateDnsResolutionOrder, startInteractiveUI, getNodeMemoryArgs, } from './gemini.js';
 import os from 'node:os';
 import v8 from 'node:v8';
+import {} from './config/config.js';
 import {} from './config/settings.js';
 import { appEvents, AppEvent } from './utils/events.js';
 import { debugLogger, } from '@google/gemini-cli-core';
@@ -32,7 +33,7 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         recordSlowRender: vi.fn(),
         writeToStdout: vi.fn((...args) => process.stdout.write(...args)),
         patchStdio: vi.fn(() => () => { }),
-        createInkStdio: vi.fn(() => ({
+        createWorkingStdio: vi.fn(() => ({
             stdout: {
                 write: vi.fn((...args) => process.stdout.write(...args)),
                 columns: 80,
@@ -176,10 +177,11 @@ describe('gemini.tsx main function', () => {
             delete process.env['SANDBOX'];
         }
         const currentListeners = process.listeners('unhandledRejection');
-        const addedListener = currentListeners.find((listener) => !initialUnhandledRejectionListeners.includes(listener));
-        if (addedListener) {
-            process.removeListener('unhandledRejection', addedListener);
-        }
+        currentListeners.forEach((listener) => {
+            if (!initialUnhandledRejectionListeners.includes(listener)) {
+                process.removeListener('unhandledRejection', listener);
+            }
+        });
         vi.restoreAllMocks();
     });
     it('verifies that we dont load the config before relaunchAppInChildProcess', async () => {
@@ -612,53 +614,6 @@ describe('gemini.tsx main function kitty protocol', () => {
         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');
@@ -729,12 +684,11 @@ describe('gemini.tsx main function kitty protocol', () => {
     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 { SessionSelector } = await import('./utils/sessionUtils.js');
+        vi.mocked(SessionSelector).mockImplementation(() => ({
+            resolveSession: vi
+                .fn()
+                .mockRejectedValue(new Error('Session not found')),
         }));
         const processExitSpy = vi
             .spyOn(process, 'exit')
@@ -793,7 +747,7 @@ describe('gemini.tsx main function kitty protocol', () => {
                 throw e;
         }
         expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error resuming session: Session not found'));
-        expect(processExitSpy).toHaveBeenCalledWith(1);
+        expect(processExitSpy).toHaveBeenCalledWith(42);
         processExitSpy.mockRestore();
         consoleErrorSpy.mockRestore();
     });
@@ -862,35 +816,27 @@ describe('gemini.tsx main function kitty protocol', () => {
         expect(processExitSpy).toHaveBeenCalledWith(0); // Should not exit on cleanup failure
         processExitSpy.mockRestore();
     });
-    it('should handle refreshAuth failure', async () => {
+    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 { loadSandboxConfig } = await import('./config/sandboxConfig.js');
+        const { readStdin } = await import('./utils/readStdin.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: {},
-            },
+            merged: { advanced: {}, security: { auth: {} }, 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: () => '',
+            isInteractive: () => false,
+            getQuestion: () => 'test-question',
             getSandbox: () => false,
             getDebugMode: () => false,
             getPolicyEngine: vi.fn(),
@@ -918,8 +864,23 @@ describe('gemini.tsx main function kitty protocol', () => {
             getFileFilteringRespectGitIgnore: () => true,
             getOutputFormat: () => 'text',
             getUsageStatisticsEnabled: () => false,
-            refreshAuth: vi.fn().mockRejectedValue(new Error('Auth refresh failed')),
         }); // 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();
         }
@@ -927,49 +888,172 @@ describe('gemini.tsx main function kitty protocol', () => {
             if (!(e instanceof MockProcessExitError))
                 throw e;
         }
-        expect(debugLoggerErrorSpy).toHaveBeenCalledWith('Error authenticating:', expect.any(Error));
-        expect(processExitSpy).toHaveBeenCalledWith(1);
+        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,
+        });
     });
-    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) => {
+});
+describe('gemini.tsx main function exit codes', () => {
+    let originalEnvNoRelaunch;
+    beforeEach(() => {
+        originalEnvNoRelaunch = process.env['CELL_CLI_NO_RELAUNCH'];
+        process.env['CELL_CLI_NO_RELAUNCH'] = 'true';
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
             throw new MockProcessExitError(code);
         });
+        // Mock stderr to avoid cluttering output
+        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        if (originalEnvNoRelaunch !== undefined) {
+            process.env['CELL_CLI_NO_RELAUNCH'] = originalEnvNoRelaunch;
+        }
+        else {
+            delete process.env['CELL_CLI_NO_RELAUNCH'];
+        }
+        vi.restoreAllMocks();
+    });
+    it('should exit with 42 for invalid input combination (prompt-interactive with non-TTY)', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        vi.mocked(loadCliConfig).mockResolvedValue({});
         vi.mocked(loadSettings).mockReturnValue({
-            merged: { advanced: {}, security: { auth: {} }, ui: {} },
-            setValue: vi.fn(),
-            forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
+            merged: { security: { auth: {} }, ui: {} },
             errors: [],
-        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
         vi.mocked(parseArguments).mockResolvedValue({
-            promptInteractive: false,
-        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+            promptInteractive: true,
+        });
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: false,
+            configurable: true,
+        });
+        try {
+            await main();
+            expect.fail('Should have thrown MockProcessExitError');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(MockProcessExitError);
+            expect(e.code).toBe(42);
+        }
+    });
+    it('should exit with 41 for auth failure during sandbox setup', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        const { loadSandboxConfig } = await import('./config/sandboxConfig.js');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        vi.mocked(loadSandboxConfig).mockResolvedValue({});
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            refreshAuth: vi.fn().mockRejectedValue(new Error('Auth failed')),
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: {
+                security: { auth: { selectedType: 'google', useExternal: false } },
+                ui: {},
+            },
+            errors: [],
+        });
+        vi.mocked(parseArguments).mockResolvedValue({});
+        vi.mock('./config/auth.js', () => ({
+            validateAuthMethod: vi.fn().mockReturnValue(null),
+        }));
+        try {
+            await main();
+            expect.fail('Should have thrown MockProcessExitError');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(MockProcessExitError);
+            expect(e.code).toBe(41);
+        }
+    });
+    it('should exit with 42 for session resume failure', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
         vi.mocked(loadCliConfig).mockResolvedValue({
             isInteractive: () => false,
-            getQuestion: () => 'test-question',
+            getQuestion: () => 'test',
             getSandbox: () => false,
             getDebugMode: () => false,
-            getPolicyEngine: vi.fn(),
-            getMessageBus: () => ({ subscribe: vi.fn() }),
-            initialize: vi.fn(),
-            getContentGeneratorConfig: vi.fn(),
+            getListExtensions: () => false,
+            getListSessions: () => false,
+            getDeleteSession: () => undefined,
             getMcpServers: () => ({}),
             getMcpClientManager: vi.fn(),
+            initialize: vi.fn(),
             getIdeMode: () => false,
             getExperimentalZedIntegration: () => false,
             getScreenReader: () => false,
             getGeminiMdFileCount: () => 0,
-            getProjectRoot: () => '/',
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
+            getToolRegistry: vi.fn(),
+            getContentGeneratorConfig: vi.fn(),
+            getModel: () => 'gemini-pro',
+            getEmbeddingModel: () => 'embedding-001',
+            getApprovalMode: () => 'default',
+            getCoreTools: () => [],
+            getTelemetryEnabled: () => false,
+            getTelemetryLogPromptsEnabled: () => false,
+            getFileFilteringRespectGitIgnore: () => true,
+            getOutputFormat: () => 'text',
+            getExtensions: () => [],
+            getUsageStatisticsEnabled: () => false,
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: { security: { auth: {} }, ui: {} },
+            errors: [],
+        });
+        vi.mocked(parseArguments).mockResolvedValue({
+            resume: 'invalid-session',
+        });
+        vi.mock('./utils/sessionUtils.js', () => ({
+            SessionSelector: vi.fn().mockImplementation(() => ({
+                resolveSession: vi
+                    .fn()
+                    .mockRejectedValue(new Error('Session not found')),
+            })),
+        }));
+        try {
+            await main();
+            expect.fail('Should have thrown MockProcessExitError');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(MockProcessExitError);
+            expect(e.code).toBe(42);
+        }
+    });
+    it('should exit with 42 for no input provided', async () => {
+        const { loadCliConfig, parseArguments } = await import('./config/config.js');
+        const { loadSettings } = await import('./config/settings.js');
+        vi.mocked(loadCliConfig).mockResolvedValue({
+            isInteractive: () => false,
+            getQuestion: () => '',
+            getSandbox: () => false,
+            getDebugMode: () => false,
             getListExtensions: () => false,
             getListSessions: () => false,
             getDeleteSession: () => undefined,
+            getMcpServers: () => ({}),
+            getMcpClientManager: vi.fn(),
+            initialize: vi.fn(),
+            getIdeMode: () => false,
+            getExperimentalZedIntegration: () => false,
+            getScreenReader: () => false,
+            getGeminiMdFileCount: () => 0,
+            getPolicyEngine: vi.fn(),
+            getMessageBus: () => ({ subscribe: vi.fn() }),
             getToolRegistry: vi.fn(),
-            getExtensions: () => [],
+            getContentGeneratorConfig: vi.fn(),
             getModel: () => 'gemini-pro',
             getEmbeddingModel: () => 'embedding-001',
             getApprovalMode: () => 'default',
@@ -978,44 +1062,26 @@ describe('gemini.tsx main function kitty protocol', () => {
             getTelemetryLogPromptsEnabled: () => false,
             getFileFilteringRespectGitIgnore: () => true,
             getOutputFormat: () => 'text',
+            getExtensions: () => [],
             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
+        });
+        vi.mocked(loadSettings).mockReturnValue({
+            merged: { security: { auth: {} }, ui: {} },
+            errors: [],
+        });
+        vi.mocked(parseArguments).mockResolvedValue({});
         Object.defineProperty(process.stdin, 'isTTY', {
-            value: false,
+            value: true, // Simulate TTY so it doesn't try to read stdin
             configurable: true,
         });
         try {
             await main();
+            expect.fail('Should have thrown MockProcessExitError');
         }
         catch (e) {
-            if (!(e instanceof MockProcessExitError))
-                throw e;
+            expect(e).toBeInstanceOf(MockProcessExitError);
+            expect(e.code).toBe(42);
         }
-        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', () => {
@@ -1098,7 +1164,6 @@ describe('startInteractiveUI', () => {
         const renderSpy = vi.mocked(render);
         await startTestInteractiveUI(mockConfig, mockSettings, mockStartupWarnings, mockWorkspaceRoot, undefined, mockInitializationResult);
         // Verify render was called with correct options
-        expect(renderSpy).toHaveBeenCalledTimes(1);
         const [reactElement, options] = renderSpy.mock.calls[0];
         // Verify render options
         expect(options).toEqual(expect.objectContaining({