@umsai/ums-code 0.0.13-v1 → 0.0.14-v1

package/dist/src/config/settings.js

@@ -3,73 +3,21 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { homedir, platform } from 'node:os';
+import * as fs from 'fs';
+import * as path from 'path';
+import { homedir, platform } from 'os';
 import * as dotenv from 'dotenv';
-import { GEMINI_CONFIG_DIR as GEMINI_DIR, getErrorMessage, Storage, } from '@umsai/ums-code-core';
+import { GEMINI_CONFIG_DIR as GEMINI_DIR, getErrorMessage, } 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 { mergeWith } from 'lodash-es';
 export const SETTINGS_DIRECTORY_NAME = '.ums';
-export const USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
-export const USER_SETTINGS_DIR = path.dirname(USER_SETTINGS_PATH);
+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 DEFAULT_EXCLUDED_ENV_VARS = ['DEBUG', 'DEBUG_MODE'];
-const MIGRATE_V2_OVERWRITE = false;
-const MIGRATION_MAP = {
-    preferredEditor: 'general.preferredEditor',
-    vimMode: 'general.vimMode',
-    disableAutoUpdate: 'general.disableAutoUpdate',
-    disableUpdateNag: 'general.disableUpdateNag',
-    checkpointing: 'general.checkpointing',
-    theme: 'ui.theme',
-    customThemes: 'ui.customThemes',
-    hideWindowTitle: 'ui.hideWindowTitle',
-    hideTips: 'ui.hideTips',
-    hideBanner: 'ui.hideBanner',
-    hideFooter: 'ui.hideFooter',
-    showMemoryUsage: 'ui.showMemoryUsage',
-    showLineNumbers: 'ui.showLineNumbers',
-    accessibility: 'ui.accessibility',
-    ideMode: 'ide.enabled',
-    hasSeenIdeIntegrationNudge: 'ide.hasSeenNudge',
-    usageStatisticsEnabled: 'privacy.usageStatisticsEnabled',
-    telemetry: 'telemetry',
-    model: 'model.name',
-    maxSessionTurns: 'model.maxSessionTurns',
-    summarizeToolOutput: 'model.summarizeToolOutput',
-    chatCompression: 'model.chatCompression',
-    skipNextSpeakerCheck: 'model.skipNextSpeakerCheck',
-    contextFileName: 'context.fileName',
-    memoryImportFormat: 'context.importFormat',
-    memoryDiscoveryMaxDirs: 'context.discoveryMaxDirs',
-    includeDirectories: 'context.includeDirectories',
-    loadMemoryFromIncludeDirectories: 'context.loadFromIncludeDirectories',
-    fileFiltering: 'context.fileFiltering',
-    sandbox: 'tools.sandbox',
-    shouldUseNodePtyShell: 'tools.usePty',
-    allowedTools: 'tools.allowed',
-    coreTools: 'tools.core',
-    excludeTools: 'tools.exclude',
-    toolDiscoveryCommand: 'tools.discoveryCommand',
-    toolCallCommand: 'tools.callCommand',
-    mcpServerCommand: 'mcp.serverCommand',
-    allowMCPServers: 'mcp.allowed',
-    excludeMCPServers: 'mcp.excluded',
-    folderTrustFeature: 'security.folderTrust.featureEnabled',
-    folderTrust: 'security.folderTrust.enabled',
-    selectedAuthType: 'security.auth.selectedType',
-    useExternalAuth: 'security.auth.useExternal',
-    autoConfigureMaxOldSpaceSize: 'advanced.autoConfigureMemory',
-    dnsResolutionOrder: 'advanced.dnsResolutionOrder',
-    excludedProjectEnvVars: 'advanced.excludedEnvVars',
-    bugCommand: 'advanced.bugCommand',
-};
 export function getSystemSettingsPath() {
-    if (process.env['QWEN_CODE_SYSTEM_SETTINGS_PATH']) {
-        return process.env['QWEN_CODE_SYSTEM_SETTINGS_PATH'];
+    if (process.env.GEMINI_CLI_SYSTEM_SETTINGS_PATH) {
+        return process.env.GEMINI_CLI_SYSTEM_SETTINGS_PATH;
     }
     if (platform() === 'darwin') {
         return '/Library/Application Support/QwenCode/settings.json';
@@ -81,306 +29,55 @@ export function getSystemSettingsPath() {
         return '/etc/qwen-code/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 function getWorkspaceSettingsPath(workspaceDir) {
+    return path.join(workspaceDir, SETTINGS_DIRECTORY_NAME, 'settings.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;
-}
-function needsMigration(settings) {
-    return !('general' in settings);
-}
-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)) {
-            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) {
-        v2Settings[remainingKey] = flatSettings[remainingKey];
-    }
-    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) {
-        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 : {};
-    // folderTrust is not supported at workspace level.
-    const { security, ...restOfWorkspace } = safeWorkspace;
-    const safeWorkspaceWithoutFolderTrust = security
-        ? {
-            ...restOfWorkspace,
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            security: (({ folderTrust, ...rest }) => rest)(security),
-        }
-        : {
-            ...restOfWorkspace,
-            security: {},
-        };
-    // 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)
-    //
-    // For properties that are arrays (e.g., includeDirectories), the arrays
-    // are concatenated. For objects (e.g., customThemes), they are merged.
-    return {
-        ...systemDefaults,
-        ...user,
-        ...safeWorkspaceWithoutFolderTrust,
-        ...system,
-        general: {
-            ...(systemDefaults.general || {}),
-            ...(user.general || {}),
-            ...(safeWorkspaceWithoutFolderTrust.general || {}),
-            ...(system.general || {}),
-        },
-        ui: {
-            ...(systemDefaults.ui || {}),
-            ...(user.ui || {}),
-            ...(safeWorkspaceWithoutFolderTrust.ui || {}),
-            ...(system.ui || {}),
-            customThemes: {
-                ...(systemDefaults.ui?.customThemes || {}),
-                ...(user.ui?.customThemes || {}),
-                ...(safeWorkspaceWithoutFolderTrust.ui?.customThemes || {}),
-                ...(system.ui?.customThemes || {}),
-            },
-        },
-        ide: {
-            ...(systemDefaults.ide || {}),
-            ...(user.ide || {}),
-            ...(safeWorkspaceWithoutFolderTrust.ide || {}),
-            ...(system.ide || {}),
-        },
-        privacy: {
-            ...(systemDefaults.privacy || {}),
-            ...(user.privacy || {}),
-            ...(safeWorkspaceWithoutFolderTrust.privacy || {}),
-            ...(system.privacy || {}),
-        },
-        telemetry: {
-            ...(systemDefaults.telemetry || {}),
-            ...(user.telemetry || {}),
-            ...(safeWorkspaceWithoutFolderTrust.telemetry || {}),
-            ...(system.telemetry || {}),
-        },
-        security: {
-            ...(systemDefaults.security || {}),
-            ...(user.security || {}),
-            ...(safeWorkspaceWithoutFolderTrust.security || {}),
-            ...(system.security || {}),
-        },
-        mcp: {
-            ...(systemDefaults.mcp || {}),
-            ...(user.mcp || {}),
-            ...(safeWorkspaceWithoutFolderTrust.mcp || {}),
-            ...(system.mcp || {}),
-        },
-        mcpServers: {
-            ...(systemDefaults.mcpServers || {}),
-            ...(user.mcpServers || {}),
-            ...(safeWorkspaceWithoutFolderTrust.mcpServers || {}),
-            ...(system.mcpServers || {}),
-        },
-        tools: {
-            ...(systemDefaults.tools || {}),
-            ...(user.tools || {}),
-            ...(safeWorkspaceWithoutFolderTrust.tools || {}),
-            ...(system.tools || {}),
-        },
-        context: {
-            ...(systemDefaults.context || {}),
-            ...(user.context || {}),
-            ...(safeWorkspaceWithoutFolderTrust.context || {}),
-            ...(system.context || {}),
-            includeDirectories: [
-                ...(systemDefaults.context?.includeDirectories || []),
-                ...(user.context?.includeDirectories || []),
-                ...(safeWorkspaceWithoutFolderTrust.context?.includeDirectories || []),
-                ...(system.context?.includeDirectories || []),
-            ],
-        },
-        model: {
-            ...(systemDefaults.model || {}),
-            ...(user.model || {}),
-            ...(safeWorkspaceWithoutFolderTrust.model || {}),
-            ...(system.model || {}),
-            chatCompression: {
-                ...(systemDefaults.model?.chatCompression || {}),
-                ...(user.model?.chatCompression || {}),
-                ...(safeWorkspaceWithoutFolderTrust.model?.chatCompression || {}),
-                ...(system.model?.chatCompression || {}),
-            },
-        },
-        advanced: {
-            ...(systemDefaults.advanced || {}),
-            ...(user.advanced || {}),
-            ...(safeWorkspaceWithoutFolderTrust.advanced || {}),
-            ...(system.advanced || {}),
-            excludedEnvVars: [
-                ...new Set([
-                    ...(systemDefaults.advanced?.excludedEnvVars || []),
-                    ...(user.advanced?.excludedEnvVars || []),
-                    ...(safeWorkspaceWithoutFolderTrust.advanced?.excludedEnvVars || []),
-                    ...(system.advanced?.excludedEnvVars || []),
-                ]),
-            ],
-        },
-        experimental: {
-            ...(systemDefaults.experimental || {}),
-            ...(user.experimental || {}),
-            ...(safeWorkspaceWithoutFolderTrust.experimental || {}),
-            ...(system.experimental || {}),
-        },
-        contentGenerator: {
-            ...(systemDefaults.contentGenerator || {}),
-            ...(user.contentGenerator || {}),
-            ...(safeWorkspaceWithoutFolderTrust.contentGenerator || {}),
-            ...(system.contentGenerator || {}),
-        },
-        systemPromptMappings: {
-            ...(systemDefaults.systemPromptMappings || {}),
-            ...(user.systemPromptMappings || {}),
-            ...(safeWorkspaceWithoutFolderTrust.systemPromptMappings || {}),
-            ...(system.systemPromptMappings || {}),
-        },
-        extensions: {
-            ...(systemDefaults.extensions || {}),
-            ...(user.extensions || {}),
-            ...(safeWorkspaceWithoutFolderTrust.extensions || {}),
-            ...(system.extensions || {}),
-            disabled: [
-                ...new Set([
-                    ...(systemDefaults.extensions?.disabled || []),
-                    ...(user.extensions?.disabled || []),
-                    ...(safeWorkspaceWithoutFolderTrust.extensions?.disabled || []),
-                    ...(system.extensions?.disabled || []),
-                ]),
-            ],
-            workspacesWithMigrationNudge: [
-                ...new Set([
-                    ...(systemDefaults.extensions?.workspacesWithMigrationNudge || []),
-                    ...(user.extensions?.workspacesWithMigrationNudge || []),
-                    ...(safeWorkspaceWithoutFolderTrust.extensions
-                        ?.workspacesWithMigrationNudge || []),
-                    ...(system.extensions?.workspacesWithMigrationNudge || []),
-                ]),
-            ],
-        },
-    };
-}
 export class LoadedSettings {
-    constructor(system, systemDefaults, user, workspace, errors, isTrusted, migratedInMemorScopes) {
+    constructor(system, user, workspace, errors) {
         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() {
-        return mergeSettings(this.system.settings, this.systemDefaults.settings, this.user.settings, this.workspace.settings, this.isTrusted);
+        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 || []),
+            ],
+        };
     }
     forScope(scope) {
         switch (scope) {
@@ -390,15 +87,13 @@ 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);
-        setNestedProperty(settingsFile.settings, key, value);
+        settingsFile.settings[key] = value;
         this._merged = this.computeMergedSettings();
         saveSettings(settingsFile);
     }
@@ -474,30 +169,30 @@ 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());
     // 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 = new Storage(process.cwd()).getWorkspaceSettingsPath();
+        const workspaceSettingsPath = getWorkspaceSettingsPath(process.cwd());
         try {
             if (fs.existsSync(workspaceSettingsPath)) {
                 const workspaceContent = fs.readFileSync(workspaceSettingsPath, 'utf-8');
@@ -515,8 +210,7 @@ export function loadEnvironment(settings) {
         try {
             const envFileContent = fs.readFileSync(envFilePath, 'utf-8');
             const parsedEnv = dotenv.parse(envFileContent);
-            const excludedVars = resolvedSettings?.advanced?.excludedEnvVars ||
-                DEFAULT_EXCLUDED_ENV_VARS;
+            const excludedVars = resolvedSettings?.excludedProjectEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
             const isProjectEnvFile = !envFilePath.includes(GEMINI_DIR);
             for (const key in parsedEnv) {
                 if (Object.hasOwn(parsedEnv, key)) {
@@ -542,13 +236,10 @@ export function loadEnvironment(settings) {
  */
 export function loadSettings(workspaceDir) {
     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());
@@ -562,96 +253,78 @@ export function loadSettings(workspaceDir) {
     }
     // We expect homedir to always exist and be resolvable.
     const realHomeDir = fs.realpathSync(resolvedHomeDir);
-    const workspaceSettingsPath = new Storage(workspaceDir).getWorkspaceSettingsPath();
-    const loadAndMigrate = (filePath, scope) => {
+    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
         try {
-            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 {};
+            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;
                 }
-                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 (workspaceSettings.theme &&
+                    workspaceSettings.theme === 'VS2015') {
+                    workspaceSettings.theme = DefaultDark.name;
                 }
-                return settingsObject;
             }
         }
         catch (error) {
             settingsErrors.push({
                 message: getErrorMessage(error),
-                path: filePath,
+                path: workspaceSettingsPath,
             });
         }
-        return {};
-    };
-    systemSettings = loadAndMigrate(systemSettingsPath, SettingScope.System);
-    systemDefaultSettings = loadAndMigrate(systemDefaultsPath, SettingScope.SystemDefaults);
-    userSettings = loadAndMigrate(USER_SETTINGS_PATH, SettingScope.User);
-    if (realWorkspaceDir !== realHomeDir) {
-        workspaceSettings = loadAndMigrate(workspaceSettingsPath, SettingScope.Workspace);
-    }
-    // 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 = mergeWith({}, systemSettings, userSettings);
-    const isTrusted = isWorkspaceTrusted(initialTrustCheckSettings) ?? 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);
-    // Now that the environment is loaded, resolve variables in the settings.
-    systemSettings = resolveEnvVarsInObject(systemSettings);
-    userSettings = resolveEnvVarsInObject(userSettings);
-    workspaceSettings = resolveEnvVarsInObject(workspaceSettings);
     // Create LoadedSettings first
     const loadedSettings = new LoadedSettings({
         path: systemSettingsPath,
         settings: systemSettings,
-    }, {
-        path: systemDefaultsPath,
-        settings: systemDefaultSettings,
     }, {
         path: USER_SETTINGS_PATH,
         settings: userSettings,
     }, {
         path: workspaceSettingsPath,
         settings: workspaceSettings,
-    }, settingsErrors, isTrusted, migratedInMemorScopes);
+    }, settingsErrors);
+    // Load environment with merged settings
+    loadEnvironment(loadedSettings.merged);
     return loadedSettings;
 }
 export function saveSettings(settingsFile) {
@@ -661,11 +334,7 @@ export function saveSettings(settingsFile) {
         if (!fs.existsSync(dirPath)) {
             fs.mkdirSync(dirPath, { recursive: true });
         }
-        let settingsToSave = settingsFile.settings;
-        if (!MIGRATE_V2_OVERWRITE) {
-            settingsToSave = migrateSettingsToV1(settingsToSave);
-        }
-        fs.writeFileSync(settingsFile.path, JSON.stringify(settingsToSave, null, 2), 'utf-8');
+        fs.writeFileSync(settingsFile.path, JSON.stringify(settingsFile.settings, null, 2), 'utf-8');
     }
     catch (error) {
         console.error('Error saving user settings file:', error);