@umsai/ums-code 0.0.14-v1 → 0.1.4-v2

package/dist/src/config/settings.js

@@ -3,21 +3,119 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { homedir, platform } from 'os';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir, platform } from 'node:os';
 import * as dotenv from 'dotenv';
-import { GEMINI_CONFIG_DIR as GEMINI_DIR, getErrorMessage, } from '@umsai/ums-code-core';
+import process from 'node:process';
+import { FatalConfigError, QWEN_DIR, getErrorMessage, Storage, } from '@umsai/ums-code-core';
 import stripJsonComments from 'strip-json-comments';
 import { DefaultLight } from '../ui/themes/default-light.js';
 import { DefaultDark } from '../ui/themes/default.js';
+import { isWorkspaceTrusted } from './trustedFolders.js';
+import { getSettingsSchema, } from './settingsSchema.js';
+import { resolveEnvVarsInObject } from '../utils/envVarResolver.js';
+import { customDeepMerge } from '../utils/deepMerge.js';
+import { updateSettingsFilePreservingFormat } from '../utils/commentJson.js';
+import { disableExtension } from './extension.js';
+function getMergeStrategyForPath(path) {
+    let current = undefined;
+    let currentSchema = getSettingsSchema();
+    for (const key of path) {
+        if (!currentSchema || !currentSchema[key]) {
+            return undefined;
+        }
+        current = currentSchema[key];
+        currentSchema = current.properties;
+    }
+    return current?.mergeStrategy;
+}
 export const SETTINGS_DIRECTORY_NAME = '.ums';
-export const USER_SETTINGS_DIR = path.join(homedir(), SETTINGS_DIRECTORY_NAME);
-export const USER_SETTINGS_PATH = path.join(USER_SETTINGS_DIR, 'settings.json');
+export const USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
+export const USER_SETTINGS_DIR = path.dirname(USER_SETTINGS_PATH);
 export const DEFAULT_EXCLUDED_ENV_VARS = ['DEBUG', 'DEBUG_MODE'];
+const MIGRATE_V2_OVERWRITE = true;
+// Settings version to track migration state
+export const SETTINGS_VERSION = 2;
+export const SETTINGS_VERSION_KEY = '$version';
+const MIGRATION_MAP = {
+    accessibility: 'ui.accessibility',
+    allowedTools: 'tools.allowed',
+    allowMCPServers: 'mcp.allowed',
+    autoAccept: 'tools.autoAccept',
+    autoConfigureMaxOldSpaceSize: 'advanced.autoConfigureMemory',
+    bugCommand: 'advanced.bugCommand',
+    chatCompression: 'model.chatCompression',
+    checkpointing: 'general.checkpointing',
+    coreTools: 'tools.core',
+    contextFileName: 'context.fileName',
+    customThemes: 'ui.customThemes',
+    customWittyPhrases: 'ui.customWittyPhrases',
+    debugKeystrokeLogging: 'general.debugKeystrokeLogging',
+    disableAutoUpdate: 'general.disableAutoUpdate',
+    disableUpdateNag: 'general.disableUpdateNag',
+    dnsResolutionOrder: 'advanced.dnsResolutionOrder',
+    enablePromptCompletion: 'general.enablePromptCompletion',
+    enforcedAuthType: 'security.auth.enforcedType',
+    excludeTools: 'tools.exclude',
+    excludeMCPServers: 'mcp.excluded',
+    excludedProjectEnvVars: 'advanced.excludedEnvVars',
+    extensionManagement: 'experimental.extensionManagement',
+    extensions: 'extensions',
+    fileFiltering: 'context.fileFiltering',
+    folderTrustFeature: 'security.folderTrust.featureEnabled',
+    folderTrust: 'security.folderTrust.enabled',
+    hasSeenIdeIntegrationNudge: 'ide.hasSeenNudge',
+    hideWindowTitle: 'ui.hideWindowTitle',
+    showStatusInTitle: 'ui.showStatusInTitle',
+    hideTips: 'ui.hideTips',
+    hideBanner: 'ui.hideBanner',
+    hideFooter: 'ui.hideFooter',
+    hideCWD: 'ui.footer.hideCWD',
+    hideSandboxStatus: 'ui.footer.hideSandboxStatus',
+    hideModelInfo: 'ui.footer.hideModelInfo',
+    hideContextSummary: 'ui.hideContextSummary',
+    showMemoryUsage: 'ui.showMemoryUsage',
+    showLineNumbers: 'ui.showLineNumbers',
+    showCitations: 'ui.showCitations',
+    ideMode: 'ide.enabled',
+    includeDirectories: 'context.includeDirectories',
+    loadMemoryFromIncludeDirectories: 'context.loadFromIncludeDirectories',
+    maxSessionTurns: 'model.maxSessionTurns',
+    mcpServers: 'mcpServers',
+    mcpServerCommand: 'mcp.serverCommand',
+    memoryImportFormat: 'context.importFormat',
+    memoryDiscoveryMaxDirs: 'context.discoveryMaxDirs',
+    model: 'model.name',
+    preferredEditor: 'general.preferredEditor',
+    sandbox: 'tools.sandbox',
+    selectedAuthType: 'security.auth.selectedType',
+    shouldUseNodePtyShell: 'tools.shell.enableInteractiveShell',
+    shellPager: 'tools.shell.pager',
+    shellShowColor: 'tools.shell.showColor',
+    skipNextSpeakerCheck: 'model.skipNextSpeakerCheck',
+    summarizeToolOutput: 'model.summarizeToolOutput',
+    telemetry: 'telemetry',
+    theme: 'ui.theme',
+    toolDiscoveryCommand: 'tools.discoveryCommand',
+    toolCallCommand: 'tools.callCommand',
+    usageStatisticsEnabled: 'privacy.usageStatisticsEnabled',
+    useExternalAuth: 'security.auth.useExternal',
+    useRipgrep: 'tools.useRipgrep',
+    vimMode: 'general.vimMode',
+    enableWelcomeBack: 'ui.enableWelcomeBack',
+    approvalMode: 'tools.approvalMode',
+    sessionTokenLimit: 'model.sessionTokenLimit',
+    contentGenerator: 'model.generationConfig',
+    skipLoopDetection: 'model.skipLoopDetection',
+    enableOpenAILogging: 'model.enableOpenAILogging',
+    tavilyApiKey: 'advanced.tavilyApiKey',
+    vlmSwitchMode: 'experimental.vlmSwitchMode',
+    visionModelPreview: 'experimental.visionModelPreview',
+};
 export function getSystemSettingsPath() {
-    if (process.env.GEMINI_CLI_SYSTEM_SETTINGS_PATH) {
-        return process.env.GEMINI_CLI_SYSTEM_SETTINGS_PATH;
+    if (process.env['QWEN_CODE_SYSTEM_SETTINGS_PATH']) {
+        return process.env['QWEN_CODE_SYSTEM_SETTINGS_PATH'];
     }
     if (platform() === 'darwin') {
         return '/Library/Application Support/QwenCode/settings.json';
@@ -29,55 +127,200 @@ export function getSystemSettingsPath() {
         return '/etc/qwen-code/settings.json';
     }
 }
-export function getWorkspaceSettingsPath(workspaceDir) {
-    return path.join(workspaceDir, SETTINGS_DIRECTORY_NAME, 'settings.json');
+export function getSystemDefaultsPath() {
+    if (process.env['QWEN_CODE_SYSTEM_DEFAULTS_PATH']) {
+        return process.env['QWEN_CODE_SYSTEM_DEFAULTS_PATH'];
+    }
+    return path.join(path.dirname(getSystemSettingsPath()), 'system-defaults.json');
 }
 export var SettingScope;
 (function (SettingScope) {
     SettingScope["User"] = "User";
     SettingScope["Workspace"] = "Workspace";
     SettingScope["System"] = "System";
+    SettingScope["SystemDefaults"] = "SystemDefaults";
 })(SettingScope || (SettingScope = {}));
+function setNestedProperty(obj, path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    if (!lastKey)
+        return;
+    let current = obj;
+    for (const key of keys) {
+        if (current[key] === undefined) {
+            current[key] = {};
+        }
+        const next = current[key];
+        if (typeof next === 'object' && next !== null) {
+            current = next;
+        }
+        else {
+            // This path is invalid, so we stop.
+            return;
+        }
+    }
+    current[lastKey] = value;
+}
+export function needsMigration(settings) {
+    // Check version field first - if present and matches current version, no migration needed
+    if (SETTINGS_VERSION_KEY in settings) {
+        const version = settings[SETTINGS_VERSION_KEY];
+        if (typeof version === 'number' && version >= SETTINGS_VERSION) {
+            return false;
+        }
+    }
+    // Fallback to legacy detection: A file needs migration if it contains any
+    // top-level key that is moved to a nested location in V2.
+    const hasV1Keys = Object.entries(MIGRATION_MAP).some(([v1Key, v2Path]) => {
+        if (v1Key === v2Path || !(v1Key in settings)) {
+            return false;
+        }
+        // If a key exists that is both a V1 key and a V2 container (like 'model'),
+        // we need to check the type. If it's an object, it's a V2 container and not
+        // a V1 key that needs migration.
+        if (KNOWN_V2_CONTAINERS.has(v1Key) &&
+            typeof settings[v1Key] === 'object' &&
+            settings[v1Key] !== null) {
+            return false;
+        }
+        return true;
+    });
+    return hasV1Keys;
+}
+function migrateSettingsToV2(flatSettings) {
+    if (!needsMigration(flatSettings)) {
+        return null;
+    }
+    const v2Settings = {};
+    const flatKeys = new Set(Object.keys(flatSettings));
+    for (const [oldKey, newPath] of Object.entries(MIGRATION_MAP)) {
+        if (flatKeys.has(oldKey)) {
+            // Safety check: If this key is a V2 container (like 'model') and it's
+            // already an object, it's likely already in V2 format. Skip migration
+            // to prevent double-nesting (e.g., model.name.name).
+            if (KNOWN_V2_CONTAINERS.has(oldKey) &&
+                typeof flatSettings[oldKey] === 'object' &&
+                flatSettings[oldKey] !== null &&
+                !Array.isArray(flatSettings[oldKey])) {
+                // This is already a V2 container, carry it over as-is
+                v2Settings[oldKey] = flatSettings[oldKey];
+                flatKeys.delete(oldKey);
+                continue;
+            }
+            setNestedProperty(v2Settings, newPath, flatSettings[oldKey]);
+            flatKeys.delete(oldKey);
+        }
+    }
+    // Preserve mcpServers at the top level
+    if (flatSettings['mcpServers']) {
+        v2Settings['mcpServers'] = flatSettings['mcpServers'];
+        flatKeys.delete('mcpServers');
+    }
+    // Carry over any unrecognized keys
+    for (const remainingKey of flatKeys) {
+        const existingValue = v2Settings[remainingKey];
+        const newValue = flatSettings[remainingKey];
+        if (typeof existingValue === 'object' &&
+            existingValue !== null &&
+            !Array.isArray(existingValue) &&
+            typeof newValue === 'object' &&
+            newValue !== null &&
+            !Array.isArray(newValue)) {
+            const pathAwareGetStrategy = (path) => getMergeStrategyForPath([remainingKey, ...path]);
+            v2Settings[remainingKey] = customDeepMerge(pathAwareGetStrategy, {}, newValue, existingValue);
+        }
+        else {
+            v2Settings[remainingKey] = newValue;
+        }
+    }
+    // Set version field to indicate this is a V2 settings file
+    v2Settings[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
+    return v2Settings;
+}
+function getNestedProperty(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (typeof current !== 'object' || current === null || !(key in current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+const REVERSE_MIGRATION_MAP = Object.fromEntries(Object.entries(MIGRATION_MAP).map(([key, value]) => [value, key]));
+// Dynamically determine the top-level keys from the V2 settings structure.
+const KNOWN_V2_CONTAINERS = new Set(Object.values(MIGRATION_MAP).map((path) => path.split('.')[0]));
+export function migrateSettingsToV1(v2Settings) {
+    const v1Settings = {};
+    const v2Keys = new Set(Object.keys(v2Settings));
+    for (const [newPath, oldKey] of Object.entries(REVERSE_MIGRATION_MAP)) {
+        const value = getNestedProperty(v2Settings, newPath);
+        if (value !== undefined) {
+            v1Settings[oldKey] = value;
+            v2Keys.delete(newPath.split('.')[0]);
+        }
+    }
+    // Preserve mcpServers at the top level
+    if (v2Settings['mcpServers']) {
+        v1Settings['mcpServers'] = v2Settings['mcpServers'];
+        v2Keys.delete('mcpServers');
+    }
+    // Carry over any unrecognized keys
+    for (const remainingKey of v2Keys) {
+        // Skip the version field - it's only for V2 format
+        if (remainingKey === SETTINGS_VERSION_KEY) {
+            continue;
+        }
+        const value = v2Settings[remainingKey];
+        if (value === undefined) {
+            continue;
+        }
+        // Don't carry over empty objects that were just containers for migrated settings.
+        if (KNOWN_V2_CONTAINERS.has(remainingKey) &&
+            typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0) {
+            continue;
+        }
+        v1Settings[remainingKey] = value;
+    }
+    return v1Settings;
+}
+function mergeSettings(system, systemDefaults, user, workspace, isTrusted) {
+    const safeWorkspace = isTrusted ? workspace : {};
+    // Settings are merged with the following precedence (last one wins for
+    // single values):
+    // 1. System Defaults
+    // 2. User Settings
+    // 3. Workspace Settings
+    // 4. System Settings (as overrides)
+    return customDeepMerge(getMergeStrategyForPath, {}, // Start with an empty object
+    systemDefaults, user, safeWorkspace, system);
+}
 export class LoadedSettings {
-    constructor(system, user, workspace, errors) {
+    constructor(system, systemDefaults, user, workspace, isTrusted, migratedInMemorScopes) {
         this.system = system;
+        this.systemDefaults = systemDefaults;
         this.user = user;
         this.workspace = workspace;
-        this.errors = errors;
+        this.isTrusted = isTrusted;
+        this.migratedInMemorScopes = migratedInMemorScopes;
         this._merged = this.computeMergedSettings();
     }
     system;
+    systemDefaults;
     user;
     workspace;
-    errors;
+    isTrusted;
+    migratedInMemorScopes;
     _merged;
     get merged() {
         return this._merged;
     }
     computeMergedSettings() {
-        const system = this.system.settings;
-        const user = this.user.settings;
-        const workspace = this.workspace.settings;
-        return {
-            ...user,
-            ...workspace,
-            ...system,
-            customThemes: {
-                ...(user.customThemes || {}),
-                ...(workspace.customThemes || {}),
-                ...(system.customThemes || {}),
-            },
-            mcpServers: {
-                ...(user.mcpServers || {}),
-                ...(workspace.mcpServers || {}),
-                ...(system.mcpServers || {}),
-            },
-            includeDirectories: [
-                ...(system.includeDirectories || []),
-                ...(user.includeDirectories || []),
-                ...(workspace.includeDirectories || []),
-            ],
-        };
+        return mergeSettings(this.system.settings, this.systemDefaults.settings, this.user.settings, this.workspace.settings, this.isTrusted);
     }
     forScope(scope) {
         switch (scope) {
@@ -87,56 +330,25 @@ export class LoadedSettings {
                 return this.workspace;
             case SettingScope.System:
                 return this.system;
+            case SettingScope.SystemDefaults:
+                return this.systemDefaults;
             default:
                 throw new Error(`Invalid scope: ${scope}`);
         }
     }
     setValue(scope, key, value) {
         const settingsFile = this.forScope(scope);
-        settingsFile.settings[key] = value;
+        setNestedProperty(settingsFile.settings, key, value);
+        setNestedProperty(settingsFile.originalSettings, key, value);
         this._merged = this.computeMergedSettings();
         saveSettings(settingsFile);
     }
 }
-function resolveEnvVarsInString(value) {
-    const envVarRegex = /\$(?:(\w+)|{([^}]+)})/g; // Find $VAR_NAME or ${VAR_NAME}
-    return value.replace(envVarRegex, (match, varName1, varName2) => {
-        const varName = varName1 || varName2;
-        if (process && process.env && typeof process.env[varName] === 'string') {
-            return process.env[varName];
-        }
-        return match;
-    });
-}
-function resolveEnvVarsInObject(obj) {
-    if (obj === null ||
-        obj === undefined ||
-        typeof obj === 'boolean' ||
-        typeof obj === 'number') {
-        return obj;
-    }
-    if (typeof obj === 'string') {
-        return resolveEnvVarsInString(obj);
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => resolveEnvVarsInObject(item));
-    }
-    if (typeof obj === 'object') {
-        const newObj = { ...obj };
-        for (const key in newObj) {
-            if (Object.prototype.hasOwnProperty.call(newObj, key)) {
-                newObj[key] = resolveEnvVarsInObject(newObj[key]);
-            }
-        }
-        return newObj;
-    }
-    return obj;
-}
 function findEnvFile(startDir) {
     let currentDir = path.resolve(startDir);
     while (true) {
-        // prefer gemini-specific .env under GEMINI_DIR
-        const geminiEnvPath = path.join(currentDir, GEMINI_DIR, '.env');
+        // prefer gemini-specific .env under QWEN_DIR
+        const geminiEnvPath = path.join(currentDir, QWEN_DIR, '.env');
         if (fs.existsSync(geminiEnvPath)) {
             return geminiEnvPath;
         }
@@ -147,7 +359,7 @@ function findEnvFile(startDir) {
         const parentDir = path.dirname(currentDir);
         if (parentDir === currentDir || !parentDir) {
             // check .env under home as fallback, again preferring gemini-specific .env
-            const homeGeminiEnvPath = path.join(homedir(), GEMINI_DIR, '.env');
+            const homeGeminiEnvPath = path.join(homedir(), QWEN_DIR, '.env');
             if (fs.existsSync(homeGeminiEnvPath)) {
                 return homeGeminiEnvPath;
             }
@@ -169,49 +381,37 @@ export function setUpCloudShellEnvironment(envFilePath) {
     if (envFilePath && fs.existsSync(envFilePath)) {
         const envFileContent = fs.readFileSync(envFilePath);
         const parsedEnv = dotenv.parse(envFileContent);
-        if (parsedEnv.GOOGLE_CLOUD_PROJECT) {
+        if (parsedEnv['GOOGLE_CLOUD_PROJECT']) {
             // .env file takes precedence in Cloud Shell
-            process.env.GOOGLE_CLOUD_PROJECT = parsedEnv.GOOGLE_CLOUD_PROJECT;
+            process.env['GOOGLE_CLOUD_PROJECT'] = parsedEnv['GOOGLE_CLOUD_PROJECT'];
         }
         else {
             // If not in .env, set to default and override global
-            process.env.GOOGLE_CLOUD_PROJECT = 'cloudshell-gca';
+            process.env['GOOGLE_CLOUD_PROJECT'] = 'cloudshell-gca';
         }
     }
     else {
         // If no .env file, set to default and override global
-        process.env.GOOGLE_CLOUD_PROJECT = 'cloudshell-gca';
+        process.env['GOOGLE_CLOUD_PROJECT'] = 'cloudshell-gca';
     }
 }
 export function loadEnvironment(settings) {
     const envFilePath = findEnvFile(process.cwd());
+    if (!isWorkspaceTrusted(settings).isTrusted) {
+        return;
+    }
     // Cloud Shell environment variable handling
-    if (process.env.CLOUD_SHELL === 'true') {
+    if (process.env['CLOUD_SHELL'] === 'true') {
         setUpCloudShellEnvironment(envFilePath);
     }
-    // If no settings provided, try to load workspace settings for exclusions
-    let resolvedSettings = settings;
-    if (!resolvedSettings) {
-        const workspaceSettingsPath = getWorkspaceSettingsPath(process.cwd());
-        try {
-            if (fs.existsSync(workspaceSettingsPath)) {
-                const workspaceContent = fs.readFileSync(workspaceSettingsPath, 'utf-8');
-                const parsedWorkspaceSettings = JSON.parse(stripJsonComments(workspaceContent));
-                resolvedSettings = resolveEnvVarsInObject(parsedWorkspaceSettings);
-            }
-        }
-        catch (_e) {
-            // Ignore errors loading workspace settings
-        }
-    }
     if (envFilePath) {
         // Manually parse and load environment variables to handle exclusions correctly.
         // This avoids modifying environment variables that were already set from the shell.
         try {
             const envFileContent = fs.readFileSync(envFilePath, 'utf-8');
             const parsedEnv = dotenv.parse(envFileContent);
-            const excludedVars = resolvedSettings?.excludedProjectEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
-            const isProjectEnvFile = !envFilePath.includes(GEMINI_DIR);
+            const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+            const isProjectEnvFile = !envFilePath.includes(QWEN_DIR);
             for (const key in parsedEnv) {
                 if (Object.hasOwn(parsedEnv, key)) {
                     // If it's a project .env file, skip loading excluded variables.
@@ -234,12 +434,15 @@ export function loadEnvironment(settings) {
  * Loads settings from user and workspace directories.
  * Project settings override user settings.
  */
-export function loadSettings(workspaceDir) {
+export function loadSettings(workspaceDir = process.cwd()) {
     let systemSettings = {};
+    let systemDefaultSettings = {};
     let userSettings = {};
     let workspaceSettings = {};
     const settingsErrors = [];
     const systemSettingsPath = getSystemSettingsPath();
+    const systemDefaultsPath = getSystemDefaultsPath();
+    const migratedInMemorScopes = new Set();
     // Resolve paths to their canonical representation to handle symlinks
     const resolvedWorkspaceDir = path.resolve(workspaceDir);
     const resolvedHomeDir = path.resolve(homedir());
@@ -253,79 +456,145 @@ export function loadSettings(workspaceDir) {
     }
     // We expect homedir to always exist and be resolvable.
     const realHomeDir = fs.realpathSync(resolvedHomeDir);
-    const workspaceSettingsPath = getWorkspaceSettingsPath(workspaceDir);
-    // Load system settings
-    try {
-        if (fs.existsSync(systemSettingsPath)) {
-            const systemContent = fs.readFileSync(systemSettingsPath, 'utf-8');
-            const parsedSystemSettings = JSON.parse(stripJsonComments(systemContent));
-            systemSettings = resolveEnvVarsInObject(parsedSystemSettings);
-        }
-    }
-    catch (error) {
-        settingsErrors.push({
-            message: getErrorMessage(error),
-            path: systemSettingsPath,
-        });
-    }
-    // Load user settings
-    try {
-        if (fs.existsSync(USER_SETTINGS_PATH)) {
-            const userContent = fs.readFileSync(USER_SETTINGS_PATH, 'utf-8');
-            const parsedUserSettings = JSON.parse(stripJsonComments(userContent));
-            userSettings = resolveEnvVarsInObject(parsedUserSettings);
-            // Support legacy theme names
-            if (userSettings.theme && userSettings.theme === 'VS') {
-                userSettings.theme = DefaultLight.name;
-            }
-            else if (userSettings.theme && userSettings.theme === 'VS2015') {
-                userSettings.theme = DefaultDark.name;
-            }
-        }
-    }
-    catch (error) {
-        settingsErrors.push({
-            message: getErrorMessage(error),
-            path: USER_SETTINGS_PATH,
-        });
-    }
-    if (realWorkspaceDir !== realHomeDir) {
-        // Load workspace settings
+    const workspaceSettingsPath = new Storage(workspaceDir).getWorkspaceSettingsPath();
+    const loadAndMigrate = (filePath, scope) => {
         try {
-            if (fs.existsSync(workspaceSettingsPath)) {
-                const projectContent = fs.readFileSync(workspaceSettingsPath, 'utf-8');
-                const parsedWorkspaceSettings = JSON.parse(stripJsonComments(projectContent));
-                workspaceSettings = resolveEnvVarsInObject(parsedWorkspaceSettings);
-                if (workspaceSettings.theme && workspaceSettings.theme === 'VS') {
-                    workspaceSettings.theme = DefaultLight.name;
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const rawSettings = JSON.parse(stripJsonComments(content));
+                if (typeof rawSettings !== 'object' ||
+                    rawSettings === null ||
+                    Array.isArray(rawSettings)) {
+                    settingsErrors.push({
+                        message: 'Settings file is not a valid JSON object.',
+                        path: filePath,
+                    });
+                    return { settings: {} };
                 }
-                else if (workspaceSettings.theme &&
-                    workspaceSettings.theme === 'VS2015') {
-                    workspaceSettings.theme = DefaultDark.name;
+                let settingsObject = rawSettings;
+                if (needsMigration(settingsObject)) {
+                    const migratedSettings = migrateSettingsToV2(settingsObject);
+                    if (migratedSettings) {
+                        if (MIGRATE_V2_OVERWRITE) {
+                            try {
+                                fs.renameSync(filePath, `${filePath}.orig`);
+                                fs.writeFileSync(filePath, JSON.stringify(migratedSettings, null, 2), 'utf-8');
+                            }
+                            catch (e) {
+                                console.error(`Error migrating settings file on disk: ${getErrorMessage(e)}`);
+                            }
+                        }
+                        else {
+                            migratedInMemorScopes.add(scope);
+                        }
+                        settingsObject = migratedSettings;
+                    }
+                }
+                else if (!(SETTINGS_VERSION_KEY in settingsObject)) {
+                    // No migration needed, but version field is missing - add it for future optimizations
+                    settingsObject[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
+                    if (MIGRATE_V2_OVERWRITE) {
+                        try {
+                            fs.writeFileSync(filePath, JSON.stringify(settingsObject, null, 2), 'utf-8');
+                        }
+                        catch (e) {
+                            console.error(`Error adding version to settings file: ${getErrorMessage(e)}`);
+                        }
+                    }
                 }
+                return { settings: settingsObject, rawJson: content };
             }
         }
         catch (error) {
             settingsErrors.push({
                 message: getErrorMessage(error),
-                path: workspaceSettingsPath,
+                path: filePath,
             });
         }
+        return { settings: {} };
+    };
+    const systemResult = loadAndMigrate(systemSettingsPath, SettingScope.System);
+    const systemDefaultsResult = loadAndMigrate(systemDefaultsPath, SettingScope.SystemDefaults);
+    const userResult = loadAndMigrate(USER_SETTINGS_PATH, SettingScope.User);
+    let workspaceResult = {
+        settings: {},
+        rawJson: undefined,
+    };
+    if (realWorkspaceDir !== realHomeDir) {
+        workspaceResult = loadAndMigrate(workspaceSettingsPath, SettingScope.Workspace);
+    }
+    const systemOriginalSettings = structuredClone(systemResult.settings);
+    const systemDefaultsOriginalSettings = structuredClone(systemDefaultsResult.settings);
+    const userOriginalSettings = structuredClone(userResult.settings);
+    const workspaceOriginalSettings = structuredClone(workspaceResult.settings);
+    // Environment variables for runtime use
+    systemSettings = resolveEnvVarsInObject(systemResult.settings);
+    systemDefaultSettings = resolveEnvVarsInObject(systemDefaultsResult.settings);
+    userSettings = resolveEnvVarsInObject(userResult.settings);
+    workspaceSettings = resolveEnvVarsInObject(workspaceResult.settings);
+    // Support legacy theme names
+    if (userSettings.ui?.theme === 'VS') {
+        userSettings.ui.theme = DefaultLight.name;
     }
+    else if (userSettings.ui?.theme === 'VS2015') {
+        userSettings.ui.theme = DefaultDark.name;
+    }
+    if (workspaceSettings.ui?.theme === 'VS') {
+        workspaceSettings.ui.theme = DefaultLight.name;
+    }
+    else if (workspaceSettings.ui?.theme === 'VS2015') {
+        workspaceSettings.ui.theme = DefaultDark.name;
+    }
+    // For the initial trust check, we can only use user and system settings.
+    const initialTrustCheckSettings = customDeepMerge(getMergeStrategyForPath, {}, systemSettings, userSettings);
+    const isTrusted = isWorkspaceTrusted(initialTrustCheckSettings).isTrusted ?? true;
+    // Create a temporary merged settings object to pass to loadEnvironment.
+    const tempMergedSettings = mergeSettings(systemSettings, systemDefaultSettings, userSettings, workspaceSettings, isTrusted);
+    // loadEnviroment depends on settings so we have to create a temp version of
+    // the settings to avoid a cycle
+    loadEnvironment(tempMergedSettings);
     // Create LoadedSettings first
-    const loadedSettings = new LoadedSettings({
+    if (settingsErrors.length > 0) {
+        const errorMessages = settingsErrors.map((error) => `Error in ${error.path}: ${error.message}`);
+        throw new FatalConfigError(`${errorMessages.join('\n')}\nPlease fix the configuration file(s) and try again.`);
+    }
+    return new LoadedSettings({
         path: systemSettingsPath,
         settings: systemSettings,
+        originalSettings: systemOriginalSettings,
+        rawJson: systemResult.rawJson,
+    }, {
+        path: systemDefaultsPath,
+        settings: systemDefaultSettings,
+        originalSettings: systemDefaultsOriginalSettings,
+        rawJson: systemDefaultsResult.rawJson,
     }, {
         path: USER_SETTINGS_PATH,
         settings: userSettings,
+        originalSettings: userOriginalSettings,
+        rawJson: userResult.rawJson,
     }, {
         path: workspaceSettingsPath,
         settings: workspaceSettings,
-    }, settingsErrors);
-    // Load environment with merged settings
-    loadEnvironment(loadedSettings.merged);
-    return loadedSettings;
+        originalSettings: workspaceOriginalSettings,
+        rawJson: workspaceResult.rawJson,
+    }, isTrusted, migratedInMemorScopes);
+}
+export function migrateDeprecatedSettings(loadedSettings, workspaceDir = process.cwd()) {
+    const processScope = (scope) => {
+        const settings = loadedSettings.forScope(scope).settings;
+        if (settings.extensions?.disabled) {
+            console.log(`Migrating deprecated extensions.disabled settings from ${scope} settings...`);
+            for (const extension of settings.extensions.disabled ?? []) {
+                disableExtension(extension, scope, workspaceDir);
+            }
+            const newExtensionsValue = { ...settings.extensions };
+            newExtensionsValue.disabled = undefined;
+            loadedSettings.setValue(scope, 'extensions', newExtensionsValue);
+        }
+    };
+    processScope(SettingScope.User);
+    processScope(SettingScope.Workspace);
 }
 export function saveSettings(settingsFile) {
     try {
@@ -334,7 +603,12 @@ export function saveSettings(settingsFile) {
         if (!fs.existsSync(dirPath)) {
             fs.mkdirSync(dirPath, { recursive: true });
         }
-        fs.writeFileSync(settingsFile.path, JSON.stringify(settingsFile.settings, null, 2), 'utf-8');
+        let settingsToSave = settingsFile.originalSettings;
+        if (!MIGRATE_V2_OVERWRITE) {
+            settingsToSave = migrateSettingsToV1(settingsToSave);
+        }
+        // Use the format-preserving update function
+        updateSettingsFilePreservingFormat(settingsFile.path, settingsToSave);
     }
     catch (error) {
         console.error('Error saving user settings file:', error);