@machina.ai/cell-cli 1.22.5-rc1 → 1.25.0-rc3

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

@@ -29,18 +29,26 @@ vi.mock('./trustedFolders.js', () => ({
         .fn()
         .mockReturnValue({ isTrusted: true, source: 'file' }),
 }));
+vi.mock('./settingsSchema.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getSettingsSchema: vi.fn(actual.getSettingsSchema),
+    };
+});
 // NOW import everything else, including the (now effectively re-exported) settings.js
-import path, * as pathActual from 'node:path'; // Restored for MOCK_WORKSPACE_SETTINGS_PATH
+import * as pathActual from 'node:path'; // Restored for MOCK_WORKSPACE_SETTINGS_PATH
+import path from 'node:path';
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
 import * as fs from 'node:fs'; // fs will be mocked separately
 import stripJsonComments from 'strip-json-comments'; // Will be mocked separately
 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';
+getSystemSettingsPath, getSystemDefaultsPath, saveSettings, getDefaultsFromSchema, loadEnvironment, } from './settings.js';
 import { FatalConfigError, CELL_DIR, AuthType } from '@google/gemini-cli-core';
-import { ExtensionManager } from './extension-manager.js';
 import { updateSettingsFilePreservingFormat } from '../utils/commentJson.js';
+import { getSettingsSchema, MergeStrategy, } from './settingsSchema.js';
 const MOCK_WORKSPACE_DIR = '/mock/workspace';
 // Use the (mocked) CELL_DIR for consistency
 const MOCK_WORKSPACE_SETTINGS_PATH = pathActual.join(MOCK_WORKSPACE_DIR, CELL_DIR, 'settings.json');
@@ -60,6 +68,7 @@ vi.mock('fs', async (importOriginal) => {
 vi.mock('./extension.js');
 const mockCoreEvents = vi.hoisted(() => ({
     emitFeedback: vi.fn(),
+    emitSettingsChanged: vi.fn(),
 }));
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const actual = await importOriginal();
@@ -114,7 +123,7 @@ describe('Settings Loading and Merging', () => {
                 },
             });
             expect(settings.workspace.settings).toEqual({});
-            expect(settings.merged).toEqual({
+            expect(settings.merged).toMatchObject({
                 security: {
                     auth: {
                         selectedType: AuthType.KEYCLOAK,
@@ -173,7 +182,7 @@ describe('Settings Loading and Merging', () => {
             else {
                 expect(settings[scope].settings).toEqual(content);
             }
-            expect(settings.merged).toEqual(expectedWithAuth);
+            expect(settings.merged).toMatchObject(expectedWithAuth);
         });
         it('should merge system, user and workspace settings, with system taking precedence over workspace, and workspace over user', () => {
             mockFsExistsSync.mockImplementation((p) => p === getSystemSettingsPath() ||
@@ -234,7 +243,7 @@ describe('Settings Loading and Merging', () => {
                 },
             });
             expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
-            expect(settings.merged).toEqual({
+            expect(settings.merged).toMatchObject({
                 ui: {
                     theme: 'system-theme',
                 },
@@ -256,124 +265,23 @@ describe('Settings Loading and Merging', () => {
                 },
             });
         });
-        it('should correctly migrate a complex legacy (v1) settings file', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const legacySettingsContent = {
-                theme: 'legacy-dark',
-                vimMode: true,
-                contextFileName: 'LEGACY_CONTEXT.md',
-                model: 'gemini-2.5-pro',
-                mcpServers: {
-                    'legacy-server-1': {
-                        command: 'npm',
-                        args: ['run', 'start:server1'],
-                        description: 'Legacy Server 1',
-                    },
-                    'legacy-server-2': {
-                        command: 'node',
-                        args: ['server2.js'],
-                        description: 'Legacy Server 2',
-                    },
-                },
-                allowMCPServers: ['legacy-server-1'],
-                someUnrecognizedSetting: 'should-be-preserved',
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(legacySettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged).toEqual({
-                ui: {
-                    theme: 'legacy-dark',
-                },
-                general: {
-                    vimMode: true,
-                },
-                context: {
-                    fileName: 'LEGACY_CONTEXT.md',
-                },
-                model: {
-                    name: 'gemini-2.5-pro',
-                },
-                mcpServers: {
-                    'legacy-server-1': {
-                        command: 'npm',
-                        args: ['run', 'start:server1'],
-                        description: 'Legacy Server 1',
-                    },
-                    'legacy-server-2': {
-                        command: 'node',
-                        args: ['server2.js'],
-                        description: 'Legacy Server 2',
-                    },
-                },
-                mcp: {
-                    allowed: ['legacy-server-1'],
-                },
-                someUnrecognizedSetting: 'should-be-preserved',
-                security: {
-                    auth: {
-                        selectedType: AuthType.KEYCLOAK,
-                    },
-                },
-            });
-        });
-        it('should rewrite allowedTools to tools.allowed during migration', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const legacySettingsContent = {
-                allowedTools: ['fs', 'shell'],
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(legacySettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.tools?.allowed).toEqual(['fs', 'shell']);
-            expect(settings.merged['allowedTools']).toBeUndefined();
-        });
-        it('should allow V2 settings to override V1 settings when both are present (zombie setting fix)', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const mixedSettingsContent = {
-                // V1 setting (migrates to ui.accessibility.screenReader = true)
-                accessibility: {
-                    screenReader: true,
-                },
-                // V2 setting (explicitly set to false)
-                ui: {
-                    accessibility: {
-                        screenReader: false,
-                    },
-                },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(mixedSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            // We expect the V2 setting (false) to win, NOT the migrated V1 setting (true)
-            expect(settings.merged.ui?.accessibility?.screenReader).toBe(false);
-        });
-        it('should correctly merge and migrate legacy array properties from multiple scopes', () => {
+        it('should correctly merge array properties from multiple scopes', () => {
             mockFsExistsSync.mockReturnValue(true);
-            const legacyUserSettings = {
-                includeDirectories: ['/user/dir'],
-                excludeTools: ['user-tool'],
-                excludedProjectEnvVars: ['USER_VAR'],
+            const userSettings = {
+                context: { includeDirectories: ['/user/dir'] },
+                tools: { exclude: ['user-tool'] },
+                advanced: { excludedEnvVars: ['USER_VAR'] },
             };
-            const legacyWorkspaceSettings = {
-                includeDirectories: ['/workspace/dir'],
-                excludeTools: ['workspace-tool'],
-                excludedProjectEnvVars: ['WORKSPACE_VAR', 'USER_VAR'],
+            const workspaceSettings = {
+                context: { includeDirectories: ['/workspace/dir'] },
+                tools: { exclude: ['workspace-tool'] },
+                advanced: { excludedEnvVars: ['WORKSPACE_VAR', 'USER_VAR'] },
             };
             fs.readFileSync.mockImplementation((p) => {
                 if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(legacyUserSettings);
+                    return JSON.stringify(userSettings);
                 if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(legacyWorkspaceSettings);
+                    return JSON.stringify(workspaceSettings);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
@@ -389,9 +297,28 @@ describe('Settings Loading and Merging', () => {
             ]);
             // Verify excludedProjectEnvVars are concatenated and de-duped
             expect(settings.merged.advanced?.excludedEnvVars).toEqual(expect.arrayContaining(['USER_VAR', 'WORKSPACE_VAR']));
-            expect(settings.merged.advanced?.excludedEnvVars).toHaveLength(2);
+            expect(settings.merged.advanced?.excludedEnvVars).toHaveLength(4);
         });
         it('should merge all settings files with the correct precedence', () => {
+            // Mock schema to test defaults application
+            const mockSchema = {
+                ui: { type: 'object', default: {}, properties: {} },
+                tools: { type: 'object', default: {}, properties: {} },
+                context: {
+                    type: 'object',
+                    default: {},
+                    properties: {
+                        discoveryMaxDirs: { type: 'number', default: 200 },
+                        includeDirectories: {
+                            type: 'array',
+                            default: [],
+                            mergeStrategy: MergeStrategy.CONCAT,
+                        },
+                    },
+                },
+                mcpServers: { type: 'object', default: {} },
+            };
+            getSettingsSchema.mockReturnValue(mockSchema);
             mockFsExistsSync.mockReturnValue(true);
             const systemDefaultsContent = {
                 ui: {
@@ -457,7 +384,7 @@ describe('Settings Loading and Merging', () => {
             expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
             expect(settings.merged).toEqual({
                 context: {
-                    fileName: 'WORKSPACE_CONTEXT.md',
+                    discoveryMaxDirs: 200,
                     includeDirectories: [
                         '/system/defaults/dir',
                         '/user/dir1',
@@ -465,14 +392,12 @@ describe('Settings Loading and Merging', () => {
                         '/workspace/dir',
                         '/system/dir',
                     ],
+                    fileName: 'WORKSPACE_CONTEXT.md',
                 },
+                mcpServers: {},
+                ui: { theme: 'system-theme' },
+                tools: { sandbox: false },
                 telemetry: false,
-                tools: {
-                    sandbox: false,
-                },
-                ui: {
-                    theme: 'system-theme',
-                },
                 security: {
                     auth: {
                         selectedType: AuthType.KEYCLOAK,
@@ -596,7 +521,7 @@ describe('Settings Loading and Merging', () => {
                 },
                 expected: {
                     key: 'advanced.excludedEnvVars',
-                    value: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'],
+                    value: ['DEBUG', 'DEBUG_MODE', 'NODE_ENV', 'CUSTOM_VAR'],
                 },
             },
             {
@@ -607,7 +532,7 @@ describe('Settings Loading and Merging', () => {
                 },
                 expected: {
                     key: 'advanced.excludedEnvVars',
-                    value: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'],
+                    value: ['DEBUG', 'DEBUG_MODE', 'WORKSPACE_DEBUG', 'WORKSPACE_VAR'],
                 },
             },
         ])('should handle $description correctly', ({ path, content, expected }) => {
@@ -654,6 +579,7 @@ describe('Settings Loading and Merging', () => {
             ]);
             expect(settings.merged.advanced?.excludedEnvVars).toEqual([
                 'DEBUG',
+                'DEBUG_MODE',
                 'NODE_ENV',
                 'USER_VAR',
                 'WORKSPACE_DEBUG',
@@ -716,8 +642,8 @@ describe('Settings Loading and Merging', () => {
             fs.readFileSync.mockReturnValue('{}');
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.telemetry).toBeUndefined();
-            expect(settings.merged.ui).toBeUndefined();
-            expect(settings.merged.mcpServers).toBeUndefined();
+            expect(settings.merged.ui).toBeDefined();
+            expect(settings.merged.mcpServers).toEqual({});
         });
         it('should merge MCP servers correctly, with workspace taking precedence', () => {
             mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH || p === MOCK_WORKSPACE_SETTINGS_PATH);
@@ -832,7 +758,7 @@ describe('Settings Loading and Merging', () => {
             mockFsExistsSync.mockReturnValue(false); // No settings files exist
             fs.readFileSync.mockReturnValue('{}');
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.mcpServers).toBeUndefined();
+            expect(settings.merged.mcpServers).toEqual({});
         });
         it('should merge MCP servers from system, user, and workspace with system taking precedence', () => {
             mockFsExistsSync.mockReturnValue(true);
@@ -950,10 +876,10 @@ describe('Settings Loading and Merging', () => {
                     expected: 0.8,
                 },
                 {
-                    description: 'should be undefined if not in any settings file',
+                    description: 'should be default if not in any settings file',
                     userContent: {},
                     workspaceContent: {},
-                    expected: undefined,
+                    expected: 0.5,
                 },
             ])('$description', ({ userContent, workspaceContent, expected }) => {
                 mockFsExistsSync.mockReturnValue(true);
@@ -1311,7 +1237,7 @@ describe('Settings Loading and Merging', () => {
                 expect(fs.readFileSync).toHaveBeenCalledWith(MOCK_ENV_SYSTEM_SETTINGS_PATH, 'utf-8');
                 expect(settings.system.path).toBe(MOCK_ENV_SYSTEM_SETTINGS_PATH);
                 expect(settings.system.settings).toEqual(systemSettingsContent);
-                expect(settings.merged).toEqual({
+                expect(settings.merged).toMatchObject({
                     ...systemSettingsContent,
                     security: {
                         auth: {
@@ -1392,8 +1318,9 @@ describe('Settings Loading and Merging', () => {
                 'DEBUG',
             ]);
             expect(settings.merged.advanced?.excludedEnvVars).toEqual([
-                'NODE_ENV',
                 'DEBUG',
+                'DEBUG_MODE',
+                'NODE_ENV',
             ]);
         });
         it('should merge excludedProjectEnvVars with workspace taking precedence', () => {
@@ -1425,6 +1352,7 @@ describe('Settings Loading and Merging', () => {
             ]);
             expect(settings.merged.advanced?.excludedEnvVars).toEqual([
                 'DEBUG',
+                'DEBUG_MODE',
                 'NODE_ENV',
                 'USER_VAR',
                 'WORKSPACE_DEBUG',
@@ -1483,315 +1411,6 @@ describe('Settings Loading and Merging', () => {
             expect(settings.merged.ui?.theme).toBe('dark'); // User setting
         });
     });
-    describe('migrateSettingsToV1', () => {
-        it('should handle an empty object', () => {
-            const v2Settings = {};
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({});
-        });
-        it('should migrate a simple v2 settings object to v1', () => {
-            const v2Settings = {
-                general: {
-                    preferredEditor: 'vscode',
-                    vimMode: true,
-                },
-                ui: {
-                    theme: 'dark',
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                preferredEditor: 'vscode',
-                vimMode: true,
-                theme: 'dark',
-            });
-        });
-        it('should handle nested properties correctly', () => {
-            const v2Settings = {
-                security: {
-                    folderTrust: {
-                        enabled: true,
-                    },
-                    auth: {
-                        selectedType: 'oauth',
-                    },
-                },
-                advanced: {
-                    autoConfigureMemory: true,
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                folderTrust: true,
-                selectedAuthType: 'oauth',
-                autoConfigureMaxOldSpaceSize: true,
-            });
-        });
-        it('should preserve mcpServers at the top level', () => {
-            const v2Settings = {
-                general: {
-                    preferredEditor: 'vscode',
-                },
-                mcpServers: {
-                    'my-server': {
-                        command: 'npm start',
-                    },
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                preferredEditor: 'vscode',
-                mcpServers: {
-                    'my-server': {
-                        command: 'npm start',
-                    },
-                },
-            });
-        });
-        it('should carry over unrecognized top-level properties', () => {
-            const v2Settings = {
-                general: {
-                    vimMode: false,
-                },
-                unrecognized: 'value',
-                another: {
-                    nested: true,
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                vimMode: false,
-                unrecognized: 'value',
-                another: {
-                    nested: true,
-                },
-            });
-        });
-        it('should handle a complex object with mixed properties', () => {
-            const v2Settings = {
-                general: {
-                    disableAutoUpdate: true,
-                },
-                ui: {
-                    hideBanner: true,
-                    customThemes: {
-                        myTheme: {},
-                    },
-                },
-                model: {
-                    name: 'gemini-pro',
-                },
-                mcpServers: {
-                    'server-1': {
-                        command: 'node server.js',
-                    },
-                },
-                unrecognized: {
-                    should: 'be-preserved',
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                disableAutoUpdate: true,
-                hideBanner: true,
-                customThemes: {
-                    myTheme: {},
-                },
-                model: 'gemini-pro',
-                mcpServers: {
-                    'server-1': {
-                        command: 'node server.js',
-                    },
-                },
-                unrecognized: {
-                    should: 'be-preserved',
-                },
-            });
-        });
-        it('should not migrate a v1 settings object', () => {
-            const v1Settings = {
-                preferredEditor: 'vscode',
-                vimMode: true,
-                theme: 'dark',
-            };
-            const migratedSettings = migrateSettingsToV1(v1Settings);
-            expect(migratedSettings).toEqual({
-                preferredEditor: 'vscode',
-                vimMode: true,
-                theme: 'dark',
-            });
-        });
-        it('should migrate a full v2 settings object to v1', () => {
-            const v2Settings = {
-                general: {
-                    preferredEditor: 'code',
-                    vimMode: true,
-                },
-                ui: {
-                    theme: 'dark',
-                },
-                privacy: {
-                    usageStatisticsEnabled: false,
-                },
-                model: {
-                    name: 'gemini-2.5-pro',
-                },
-                context: {
-                    fileName: 'CONTEXT.md',
-                    includeDirectories: ['/src'],
-                },
-                tools: {
-                    sandbox: true,
-                    exclude: ['toolA'],
-                },
-                mcp: {
-                    allowed: ['server1'],
-                },
-                security: {
-                    folderTrust: {
-                        enabled: true,
-                    },
-                },
-                advanced: {
-                    dnsResolutionOrder: 'ipv4first',
-                    excludedEnvVars: ['SECRET'],
-                },
-                mcpServers: {
-                    'my-server': {
-                        command: 'npm start',
-                    },
-                },
-                unrecognizedTopLevel: {
-                    value: 'should be preserved',
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                preferredEditor: 'code',
-                vimMode: true,
-                theme: 'dark',
-                usageStatisticsEnabled: false,
-                model: 'gemini-2.5-pro',
-                contextFileName: 'CONTEXT.md',
-                includeDirectories: ['/src'],
-                sandbox: true,
-                excludeTools: ['toolA'],
-                allowMCPServers: ['server1'],
-                folderTrust: true,
-                dnsResolutionOrder: 'ipv4first',
-                excludedProjectEnvVars: ['SECRET'],
-                mcpServers: {
-                    'my-server': {
-                        command: 'npm start',
-                    },
-                },
-                unrecognizedTopLevel: {
-                    value: 'should be preserved',
-                },
-            });
-        });
-        it('should handle partial v2 settings', () => {
-            const v2Settings = {
-                general: {
-                    vimMode: false,
-                },
-                ui: {},
-                model: {
-                    name: 'gemini-2.5-pro',
-                },
-                unrecognized: 'value',
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                vimMode: false,
-                model: 'gemini-2.5-pro',
-                unrecognized: 'value',
-            });
-        });
-        it('should handle settings with different data types', () => {
-            const v2Settings = {
-                general: {
-                    vimMode: false,
-                },
-                model: {
-                    maxSessionTurns: -1,
-                },
-                context: {
-                    includeDirectories: [],
-                },
-                security: {
-                    folderTrust: {
-                        enabled: undefined,
-                    },
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                vimMode: false,
-                maxSessionTurns: -1,
-                includeDirectories: [],
-                security: {
-                    folderTrust: {
-                        enabled: undefined,
-                    },
-                },
-            });
-        });
-        it('should preserve unrecognized top-level keys', () => {
-            const v2Settings = {
-                general: {
-                    vimMode: true,
-                },
-                customTopLevel: {
-                    a: 1,
-                    b: [2],
-                },
-                anotherOne: 'hello',
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                vimMode: true,
-                customTopLevel: {
-                    a: 1,
-                    b: [2],
-                },
-                anotherOne: 'hello',
-            });
-        });
-        it('should handle an empty v2 settings object', () => {
-            const v2Settings = {};
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({});
-        });
-        it('should correctly handle mcpServers at the top level', () => {
-            const v2Settings = {
-                mcpServers: {
-                    serverA: { command: 'a' },
-                },
-                mcp: {
-                    allowed: ['serverA'],
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                mcpServers: {
-                    serverA: { command: 'a' },
-                },
-                allowMCPServers: ['serverA'],
-            });
-        });
-        it('should correctly migrate customWittyPhrases', () => {
-            const v2Settings = {
-                ui: {
-                    customWittyPhrases: ['test phrase'],
-                },
-            };
-            const v1Settings = migrateSettingsToV1(v2Settings);
-            expect(v1Settings).toEqual({
-                customWittyPhrases: ['test phrase'],
-            });
-        });
-    });
     describe('loadEnvironment', () => {
         function setup({ isFolderTrustEnabled = true, isWorkspaceTrustedValue = true, }) {
             delete process.env['TESTTEST']; // reset
@@ -1833,156 +1452,6 @@ describe('Settings Loading and Merging', () => {
             expect(process.env['TESTTEST']).not.toEqual('1234');
         });
     });
-    describe('needsMigration', () => {
-        it('should return false for an empty object', () => {
-            expect(needsMigration({})).toBe(false);
-        });
-        it('should return false for settings that are already in V2 format', () => {
-            const v2Settings = {
-                ui: {
-                    theme: 'dark',
-                },
-                tools: {
-                    sandbox: true,
-                },
-            };
-            expect(needsMigration(v2Settings)).toBe(false);
-        });
-        it('should return true for settings with a V1 key that needs to be moved', () => {
-            const v1Settings = {
-                theme: 'dark', // v1 key
-            };
-            expect(needsMigration(v1Settings)).toBe(true);
-        });
-        it('should return true for settings with a mix of V1 and V2 keys', () => {
-            const mixedSettings = {
-                theme: 'dark', // v1 key
-                tools: {
-                    sandbox: true, // v2 key
-                },
-            };
-            expect(needsMigration(mixedSettings)).toBe(true);
-        });
-        it('should return false for settings with only V1 keys that are the same in V2', () => {
-            const v1Settings = {
-                mcpServers: {},
-                telemetry: {},
-                extensions: [],
-            };
-            expect(needsMigration(v1Settings)).toBe(false);
-        });
-        it('should return true for settings with a mix of V1 keys that are the same in V2 and V1 keys that need moving', () => {
-            const v1Settings = {
-                mcpServers: {}, // same in v2
-                theme: 'dark', // needs moving
-            };
-            expect(needsMigration(v1Settings)).toBe(true);
-        });
-        it('should return false for settings with unrecognized keys', () => {
-            const settings = {
-                someUnrecognizedKey: 'value',
-            };
-            expect(needsMigration(settings)).toBe(false);
-        });
-        it('should return false for settings with v2 keys and unrecognized keys', () => {
-            const settings = {
-                ui: { theme: 'dark' },
-                someUnrecognizedKey: 'value',
-            };
-            expect(needsMigration(settings)).toBe(false);
-        });
-    });
-    describe('migrateDeprecatedSettings', () => {
-        let mockFsExistsSync;
-        let mockFsReadFileSync;
-        beforeEach(() => {
-            vi.resetAllMocks();
-            mockFsExistsSync = vi.mocked(fs.existsSync);
-            mockFsExistsSync.mockReturnValue(true);
-            mockFsReadFileSync = vi.mocked(fs.readFileSync);
-            mockFsReadFileSync.mockReturnValue('{}');
-            vi.mocked(isWorkspaceTrusted).mockReturnValue({
-                isTrusted: true,
-                source: undefined,
-            });
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-        });
-        it('should migrate disabled extensions from user and workspace settings', () => {
-            const userSettingsContent = {
-                extensions: {
-                    disabled: ['user-ext-1', 'shared-ext'],
-                },
-            };
-            const workspaceSettingsContent = {
-                extensions: {
-                    disabled: ['workspace-ext-1', 'shared-ext'],
-                },
-            };
-            mockFsReadFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '{}';
-            });
-            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
-            const setValueSpy = vi.spyOn(loadedSettings, 'setValue');
-            const extensionManager = new ExtensionManager({
-                settings: loadedSettings.merged,
-                workspaceDir: MOCK_WORKSPACE_DIR,
-                requestConsent: vi.fn(),
-                requestSetting: vi.fn(),
-            });
-            const mockDisableExtension = vi.spyOn(extensionManager, 'disableExtension');
-            mockDisableExtension.mockImplementation(async () => { });
-            migrateDeprecatedSettings(loadedSettings, extensionManager);
-            // Check user settings migration
-            expect(mockDisableExtension).toHaveBeenCalledWith('user-ext-1', SettingScope.User);
-            expect(mockDisableExtension).toHaveBeenCalledWith('shared-ext', SettingScope.User);
-            // Check workspace settings migration
-            expect(mockDisableExtension).toHaveBeenCalledWith('workspace-ext-1', SettingScope.Workspace);
-            expect(mockDisableExtension).toHaveBeenCalledWith('shared-ext', SettingScope.Workspace);
-            // Check that setValue was called to remove the deprecated setting
-            expect(setValueSpy).toHaveBeenCalledWith(SettingScope.User, 'extensions', {
-                disabled: undefined,
-            });
-            expect(setValueSpy).toHaveBeenCalledWith(SettingScope.Workspace, 'extensions', {
-                disabled: undefined,
-            });
-        });
-        it('should not do anything if there are no deprecated settings', () => {
-            const userSettingsContent = {
-                extensions: {
-                    enabled: ['user-ext-1'],
-                },
-            };
-            const workspaceSettingsContent = {
-                someOtherSetting: 'value',
-            };
-            mockFsReadFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '{}';
-            });
-            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
-            const setValueSpy = vi.spyOn(loadedSettings, 'setValue');
-            const extensionManager = new ExtensionManager({
-                settings: loadedSettings.merged,
-                workspaceDir: MOCK_WORKSPACE_DIR,
-                requestConsent: vi.fn(),
-                requestSetting: vi.fn(),
-            });
-            const mockDisableExtension = vi.spyOn(extensionManager, 'disableExtension');
-            mockDisableExtension.mockImplementation(async () => { });
-            migrateDeprecatedSettings(loadedSettings, extensionManager);
-            expect(mockDisableExtension).not.toHaveBeenCalled();
-            expect(setValueSpy).not.toHaveBeenCalled();
-        });
-    });
     describe('saveSettings', () => {
         it('should save settings using updateSettingsFilePreservingFormat', () => {
             const mockUpdateSettings = vi.mocked(updateSettingsFilePreservingFormat);
@@ -2026,5 +1495,187 @@ describe('Settings Loading and Merging', () => {
             expect(mockCoreEvents.emitFeedback).toHaveBeenCalledWith('error', 'There was an error saving your latest settings changes.', error);
         });
     });
+    describe('LoadedSettings and remote admin settings', () => {
+        it('should prioritize remote admin settings over file-based admin settings', () => {
+            mockFsExistsSync.mockReturnValue(true);
+            const systemSettingsContent = {
+                admin: {
+                    // These should be ignored
+                    secureModeEnabled: true,
+                    mcp: { enabled: false },
+                    extensions: { enabled: false },
+                },
+                // A non-admin setting to ensure it's still processed
+                ui: { theme: 'system-theme' },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (p === getSystemSettingsPath()) {
+                    return JSON.stringify(systemSettingsContent);
+                }
+                return '{}';
+            });
+            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
+            // 1. Verify that on initial load, file-based admin settings are ignored
+            //    and schema defaults are used instead.
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false); // default: false
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true); // default: true
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true); // default: true
+            expect(loadedSettings.merged.ui?.theme).toBe('system-theme'); // non-admin setting should be loaded
+            // 2. Now, set remote admin settings.
+            loadedSettings.setRemoteAdminSettings({
+                secureModeEnabled: true,
+                mcpSetting: { mcpEnabled: false },
+                cliFeatureSetting: { extensionsSetting: { extensionsEnabled: false } },
+            });
+            // 3. Verify that remote admin settings take precedence.
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(true);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(false);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(false);
+            // non-admin setting should remain unchanged
+            expect(loadedSettings.merged.ui?.theme).toBe('system-theme');
+        });
+        it('should set remote admin settings and recompute merged settings', () => {
+            mockFsExistsSync.mockReturnValue(true);
+            const systemSettingsContent = {
+                admin: {
+                    secureModeEnabled: false,
+                    mcp: { enabled: false },
+                    extensions: { enabled: false },
+                },
+                ui: { theme: 'initial-theme' },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (p === getSystemSettingsPath()) {
+                    return JSON.stringify(systemSettingsContent);
+                }
+                return '{}';
+            });
+            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
+            // Ensure initial state from defaults (as file-based admin settings are ignored)
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true);
+            expect(loadedSettings.merged.ui?.theme).toBe('initial-theme');
+            const newRemoteSettings = {
+                secureModeEnabled: true,
+                mcpSetting: { mcpEnabled: false },
+                cliFeatureSetting: { extensionsSetting: { extensionsEnabled: false } },
+            };
+            loadedSettings.setRemoteAdminSettings(newRemoteSettings);
+            // Verify that remote admin settings are applied
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(true);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(false);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(false);
+            // Non-admin settings should remain untouched
+            expect(loadedSettings.merged.ui?.theme).toBe('initial-theme');
+            // Verify that calling setRemoteAdminSettings with partial data overwrites previous remote settings
+            // and missing properties revert to schema defaults.
+            loadedSettings.setRemoteAdminSettings({ secureModeEnabled: false });
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true); // Reverts to default: true
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true); // Reverts to default: true
+        });
+        it('should correctly handle undefined remote admin settings', () => {
+            mockFsExistsSync.mockReturnValue(true);
+            const systemSettingsContent = {
+                ui: { theme: 'initial-theme' },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (p === getSystemSettingsPath()) {
+                    return JSON.stringify(systemSettingsContent);
+                }
+                return '{}';
+            });
+            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
+            // Should have default admin settings
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true);
+            loadedSettings.setRemoteAdminSettings({}); // Set empty remote settings
+            // Admin settings should revert to defaults because there are no remote overrides
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true);
+        });
+        it('should correctly handle missing properties in remote admin settings', () => {
+            mockFsExistsSync.mockReturnValue(true);
+            const systemSettingsContent = {
+                admin: {
+                    secureModeEnabled: true,
+                },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (p === getSystemSettingsPath()) {
+                    return JSON.stringify(systemSettingsContent);
+                }
+                return '{}';
+            });
+            const loadedSettings = loadSettings(MOCK_WORKSPACE_DIR);
+            // Ensure initial state from defaults (as file-based admin settings are ignored)
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true);
+            // Set remote settings with only secureModeEnabled
+            loadedSettings.setRemoteAdminSettings({
+                secureModeEnabled: true,
+            });
+            // Verify secureModeEnabled is updated, others remain defaults
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(true);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true);
+            // Set remote settings with only mcpSetting.mcpEnabled
+            loadedSettings.setRemoteAdminSettings({
+                mcpSetting: { mcpEnabled: false },
+            });
+            // Verify mcpEnabled is updated, others remain defaults (secureModeEnabled reverts to default:false)
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(false);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(true);
+            // Set remote settings with only cliFeatureSetting.extensionsSetting.extensionsEnabled
+            loadedSettings.setRemoteAdminSettings({
+                cliFeatureSetting: { extensionsSetting: { extensionsEnabled: false } },
+            });
+            // Verify extensionsEnabled is updated, others remain defaults
+            expect(loadedSettings.merged.admin?.secureModeEnabled).toBe(false);
+            expect(loadedSettings.merged.admin?.mcp?.enabled).toBe(true);
+            expect(loadedSettings.merged.admin?.extensions?.enabled).toBe(false);
+        });
+    });
+    describe('getDefaultsFromSchema', () => {
+        it('should extract defaults from a schema', () => {
+            const mockSchema = {
+                prop1: {
+                    type: 'string',
+                    default: 'default1',
+                    label: 'Prop 1',
+                    category: 'General',
+                    requiresRestart: false,
+                },
+                nested: {
+                    type: 'object',
+                    label: 'Nested',
+                    category: 'General',
+                    requiresRestart: false,
+                    default: {},
+                    properties: {
+                        prop2: {
+                            type: 'number',
+                            default: 42,
+                            label: 'Prop 2',
+                            category: 'General',
+                            requiresRestart: false,
+                        },
+                    },
+                },
+            };
+            const defaults = getDefaultsFromSchema(mockSchema);
+            expect(defaults).toEqual({
+                prop1: 'default1',
+                nested: {
+                    prop2: 42,
+                },
+            });
+        });
+    });
 });
 //# sourceMappingURL=settings.test.js.map