@machina.ai/cell-cli 1.18.4-rc1 → 1.19.4-rc1

package/dist/src/config/settings.test.js

@@ -38,7 +38,7 @@ import { isWorkspaceTrusted } from './trustedFolders.js';
 // These imports will get the versions from the vi.mock('./settings.js', ...) factory.
 import { loadSettings, USER_SETTINGS_PATH, // This IS the mocked path.
 getSystemSettingsPath, getSystemDefaultsPath, migrateSettingsToV1, needsMigration, loadEnvironment, migrateDeprecatedSettings, SettingScope, saveSettings, } from './settings.js';
-import { FatalConfigError, CELL_DIR } from '@google/gemini-cli-core';
+import { FatalConfigError, CELL_DIR, AuthType } from '@google/gemini-cli-core';
 import { ExtensionManager } from './extension-manager.js';
 import { updateSettingsFilePreservingFormat } from '../utils/commentJson.js';
 const MOCK_WORKSPACE_DIR = '/mock/workspace';
@@ -108,78 +108,66 @@ describe('Settings Loading and Merging', () => {
             expect(settings.system.settings).toEqual({});
             expect(settings.user.settings).toEqual({});
             expect(settings.workspace.settings).toEqual({});
-            expect(settings.merged).toEqual({});
-        });
-        it('should load system settings if only system file exists', () => {
-            mockFsExistsSync.mockImplementation((p) => p === getSystemSettingsPath());
-            const systemSettingsContent = {
-                ui: {
-                    theme: 'system-default',
-                },
-                tools: {
-                    sandbox: false,
-                },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
-                    return JSON.stringify(systemSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(getSystemSettingsPath(), 'utf-8');
-            expect(settings.system.settings).toEqual(systemSettingsContent);
-            expect(settings.user.settings).toEqual({});
-            expect(settings.workspace.settings).toEqual({});
             expect(settings.merged).toEqual({
-                ...systemSettingsContent,
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
             });
         });
-        it('should load user settings if only user file exists', () => {
-            const expectedUserSettingsPath = USER_SETTINGS_PATH; // Use the path actually resolved by the (mocked) module
-            mockFsExistsSync.mockImplementation((p) => p === expectedUserSettingsPath);
-            const userSettingsContent = {
-                ui: {
-                    theme: 'dark',
-                },
-                context: {
-                    fileName: 'USER_CONTEXT.md',
+        it.each([
+            {
+                scope: 'system',
+                path: getSystemSettingsPath(),
+                content: {
+                    ui: { theme: 'system-default' },
+                    tools: { sandbox: false },
+                },
+            },
+            {
+                scope: 'user',
+                path: USER_SETTINGS_PATH,
+                content: {
+                    ui: { theme: 'dark' },
+                    context: { fileName: 'USER_CONTEXT.md' },
+                },
+            },
+            {
+                scope: 'workspace',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: {
+                    tools: { sandbox: true },
+                    context: { fileName: 'WORKSPACE_CONTEXT.md' },
                 },
-            };
+            },
+        ])('should load $scope settings if only $scope file exists', ({ scope, path, content }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === expectedUserSettingsPath)
-                    return JSON.stringify(userSettingsContent);
+                if (p === path)
+                    return JSON.stringify(content);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(expectedUserSettingsPath, 'utf-8');
-            expect(settings.user.settings).toEqual(userSettingsContent);
-            expect(settings.workspace.settings).toEqual({});
-            expect(settings.merged).toEqual({
-                ...userSettingsContent,
-            });
-        });
-        it('should load workspace settings if only workspace file exists', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                tools: {
-                    sandbox: true,
-                },
-                context: {
-                    fileName: 'WORKSPACE_CONTEXT.md',
+            expect(fs.readFileSync).toHaveBeenCalledWith(path, 'utf-8');
+            // Prepare expected object with default auth
+            const expectedWithAuth = {
+                ...content,
+                security: {
+                    ...(content.security || {}),
+                    auth: {
+                        ...(content.security?.auth || {}),
+                        selectedType: AuthType.KEYCLOAK,
+                    },
                 },
             };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(MOCK_WORKSPACE_SETTINGS_PATH, 'utf-8');
-            expect(settings.user.settings).toEqual({});
-            expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
-            expect(settings.merged).toEqual({
-                ...workspaceSettingsContent,
-            });
+            if (scope === 'user') {
+                expect(settings.user.settings).toEqual(expectedWithAuth);
+            }
+            else {
+                expect(settings[scope].settings).toEqual(content);
+            }
+            expect(settings.merged).toEqual(expectedWithAuth);
         });
         it('should merge system, user and workspace settings, with system taking precedence over workspace, and workspace over user', () => {
             mockFsExistsSync.mockImplementation((p) => p === getSystemSettingsPath() ||
@@ -231,7 +219,14 @@ describe('Settings Loading and Merging', () => {
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.system.settings).toEqual(systemSettingsContent);
-            expect(settings.user.settings).toEqual(userSettingsContent);
+            expect(settings.user.settings).toEqual({
+                ...userSettingsContent,
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
+            });
             expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
             expect(settings.merged).toEqual({
                 ui: {
@@ -248,6 +243,11 @@ describe('Settings Loading and Merging', () => {
                 mcp: {
                     allowed: ['server1', 'server2'],
                 },
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
             });
         });
         it('should correctly migrate a complex legacy (v1) settings file', () => {
@@ -307,6 +307,11 @@ describe('Settings Loading and Merging', () => {
                     allowed: ['legacy-server-1'],
                 },
                 someUnrecognizedSetting: 'should-be-preserved',
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
             });
         });
         it('should rewrite allowedTools to tools.allowed during migration', () => {
@@ -412,7 +417,14 @@ describe('Settings Loading and Merging', () => {
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.systemDefaults.settings).toEqual(systemDefaultsContent);
             expect(settings.system.settings).toEqual(systemSettingsContent);
-            expect(settings.user.settings).toEqual(userSettingsContent);
+            expect(settings.user.settings).toEqual({
+                ...userSettingsContent,
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
+            });
             expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
             expect(settings.merged).toEqual({
                 context: {
@@ -432,6 +444,11 @@ describe('Settings Loading and Merging', () => {
                 ui: {
                     theme: 'system-theme',
                 },
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
             });
         });
         it('should use folderTrust from workspace settings when trusted', () => {
@@ -529,64 +546,55 @@ describe('Settings Loading and Merging', () => {
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.security?.disableYoloMode).toBe(true); // System setting should be used
         });
-        it('should handle contextFileName correctly when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = { context: { fileName: 'CUSTOM.md' } };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.context?.fileName).toBe('CUSTOM.md');
-        });
-        it('should handle contextFileName correctly when only in workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                context: { fileName: 'PROJECT_SPECIFIC.md' },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.context?.fileName).toBe('PROJECT_SPECIFIC.md');
-        });
-        it('should handle excludedProjectEnvVars correctly when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = {
-                general: {},
-                advanced: { excludedEnvVars: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'] },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.advanced?.excludedEnvVars).toEqual([
-                'DEBUG',
-                'NODE_ENV',
-                'CUSTOM_VAR',
-            ]);
-        });
-        it('should handle excludedProjectEnvVars correctly when only in workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                general: {},
-                advanced: { excludedEnvVars: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'] },
-            };
+        it.each([
+            {
+                description: 'contextFileName in user settings',
+                path: USER_SETTINGS_PATH,
+                content: { context: { fileName: 'CUSTOM.md' } },
+                expected: { key: 'context.fileName', value: 'CUSTOM.md' },
+            },
+            {
+                description: 'contextFileName in workspace settings',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: { context: { fileName: 'PROJECT_SPECIFIC.md' } },
+                expected: { key: 'context.fileName', value: 'PROJECT_SPECIFIC.md' },
+            },
+            {
+                description: 'excludedProjectEnvVars in user settings',
+                path: USER_SETTINGS_PATH,
+                content: {
+                    advanced: { excludedEnvVars: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'] },
+                },
+                expected: {
+                    key: 'advanced.excludedEnvVars',
+                    value: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'],
+                },
+            },
+            {
+                description: 'excludedProjectEnvVars in workspace settings',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: {
+                    advanced: { excludedEnvVars: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'] },
+                },
+                expected: {
+                    key: 'advanced.excludedEnvVars',
+                    value: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'],
+                },
+            },
+        ])('should handle $description correctly', ({ path, content, expected }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
+                if (p === path)
+                    return JSON.stringify(content);
+                return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.advanced?.excludedEnvVars).toEqual([
-                'WORKSPACE_DEBUG',
-                'WORKSPACE_VAR',
-            ]);
+            const keys = expected.key.split('.');
+            let result = settings.merged;
+            for (const key of keys) {
+                result = result[key];
+            }
+            expect(result).toEqual(expected.value);
         });
         it('should merge excludedProjectEnvVars with workspace taking precedence over user', () => {
             mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH || p === MOCK_WORKSPACE_SETTINGS_PATH);
@@ -637,27 +645,28 @@ describe('Settings Loading and Merging', () => {
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.context?.fileName).toBeUndefined();
         });
-        it('should load telemetry setting from user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = { telemetry: { enabled: true } };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.telemetry?.enabled).toBe(true);
-        });
-        it('should load telemetry setting from workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = { telemetry: { enabled: false } };
+        it.each([
+            {
+                scope: 'user',
+                path: USER_SETTINGS_PATH,
+                content: { telemetry: { enabled: true } },
+                expected: true,
+            },
+            {
+                scope: 'workspace',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: { telemetry: { enabled: false } },
+                expected: false,
+            },
+        ])('should load telemetry setting from $scope settings', ({ path, content, expected }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
+                if (p === path)
+                    return JSON.stringify(content);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.telemetry?.enabled).toBe(false);
+            expect(settings.merged.telemetry?.enabled).toBe(expected);
         });
         it('should prioritize workspace telemetry setting over user setting', () => {
             mockFsExistsSync.mockReturnValue(true);
@@ -717,7 +726,14 @@ describe('Settings Loading and Merging', () => {
                 return '';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.user.settings).toEqual(userSettingsContent);
+            expect(settings.user.settings).toEqual({
+                ...userSettingsContent,
+                security: {
+                    auth: {
+                        selectedType: AuthType.KEYCLOAK,
+                    },
+                },
+            });
             expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
             expect(settings.merged.mcpServers).toEqual({
                 'user-server': {
@@ -736,51 +752,52 @@ describe('Settings Loading and Merging', () => {
                 },
             });
         });
-        it('should handle MCP servers when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = {
-                mcpServers: {
+        it.each([
+            {
+                scope: 'user',
+                path: USER_SETTINGS_PATH,
+                content: {
+                    mcpServers: {
+                        'user-only-server': {
+                            command: 'user-only-command',
+                            description: 'User only server',
+                        },
+                    },
+                },
+                expected: {
                     'user-only-server': {
                         command: 'user-only-command',
                         description: 'User only server',
                     },
                 },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.mcpServers).toEqual({
-                'user-only-server': {
-                    command: 'user-only-command',
-                    description: 'User only server',
+            },
+            {
+                scope: 'workspace',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: {
+                    mcpServers: {
+                        'workspace-only-server': {
+                            command: 'workspace-only-command',
+                            description: 'Workspace only server',
+                        },
+                    },
                 },
-            });
-        });
-        it('should handle MCP servers when only in workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                mcpServers: {
+                expected: {
                     'workspace-only-server': {
                         command: 'workspace-only-command',
                         description: 'Workspace only server',
                     },
                 },
-            };
+            },
+        ])('should handle MCP servers when only in $scope settings', ({ path, content, expected }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
+                if (p === path)
+                    return JSON.stringify(content);
+                return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.mcpServers).toEqual({
-                'workspace-only-server': {
-                    command: 'workspace-only-command',
-                    description: 'Workspace only server',
-                },
-            });
+            expect(settings.merged.mcpServers).toEqual(expected);
         });
         it('should have mcpServers as undefined if not in any settings file', () => {
             mockFsExistsSync.mockReturnValue(false); // No settings files exist
@@ -883,65 +900,44 @@ describe('Settings Loading and Merging', () => {
                 excluded: ['workspace-excluded'],
             });
         });
-        it('should merge compressionThreshold settings, with workspace taking precedence', () => {
-            mockFsExistsSync.mockReturnValue(true);
-            const userSettingsContent = {
-                general: {},
-                model: { compressionThreshold: 0.5 },
-            };
-            const workspaceSettingsContent = {
-                general: {},
-                model: { compressionThreshold: 0.8 },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.user.settings.model?.compressionThreshold).toEqual(0.5);
-            expect(settings.workspace.settings.model?.compressionThreshold).toEqual(0.8);
-            expect(settings.merged.model?.compressionThreshold).toEqual(0.8);
-        });
-        it('should merge output format settings, with workspace taking precedence', () => {
-            mockFsExistsSync.mockReturnValue(true);
-            const userSettingsContent = {
-                output: { format: 'text' },
-            };
-            const workspaceSettingsContent = {
-                output: { format: 'json' },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.output?.format).toBe('json');
-        });
-        it('should handle compressionThreshold when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = {
-                general: {},
-                model: { compressionThreshold: 0.5 },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '{}';
+        describe('compressionThreshold settings', () => {
+            it.each([
+                {
+                    description: 'should be taken from user settings if only present there',
+                    userContent: { model: { compressionThreshold: 0.5 } },
+                    workspaceContent: {},
+                    expected: 0.5,
+                },
+                {
+                    description: 'should be taken from workspace settings if only present there',
+                    userContent: {},
+                    workspaceContent: { model: { compressionThreshold: 0.8 } },
+                    expected: 0.8,
+                },
+                {
+                    description: 'should prioritize workspace settings over user settings',
+                    userContent: { model: { compressionThreshold: 0.5 } },
+                    workspaceContent: { model: { compressionThreshold: 0.8 } },
+                    expected: 0.8,
+                },
+                {
+                    description: 'should be undefined if not in any settings file',
+                    userContent: {},
+                    workspaceContent: {},
+                    expected: undefined,
+                },
+            ])('$description', ({ userContent, workspaceContent, expected }) => {
+                mockFsExistsSync.mockReturnValue(true);
+                fs.readFileSync.mockImplementation((p) => {
+                    if (p === USER_SETTINGS_PATH)
+                        return JSON.stringify(userContent);
+                    if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                        return JSON.stringify(workspaceContent);
+                    return '{}';
+                });
+                const settings = loadSettings(MOCK_WORKSPACE_DIR);
+                expect(settings.merged.model?.compressionThreshold).toEqual(expected);
             });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.model?.compressionThreshold).toEqual(0.5);
-        });
-        it('should have model as undefined if not in any settings file', () => {
-            mockFsExistsSync.mockReturnValue(false); // No settings files exist
-            fs.readFileSync.mockReturnValue('{}');
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.model).toBeUndefined();
         });
         it('should use user compressionThreshold if workspace does not define it', () => {
             mockFsExistsSync.mockReturnValue(true);
@@ -1288,6 +1284,11 @@ describe('Settings Loading and Merging', () => {
                 expect(settings.system.settings).toEqual(systemSettingsContent);
                 expect(settings.merged).toEqual({
                     ...systemSettingsContent,
+                    security: {
+                        auth: {
+                            selectedType: AuthType.KEYCLOAK,
+                        },
+                    },
                 });
             });
         });