@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

package/dist/core/settings-manager.js

@@ -0,0 +1,1277 @@
+import { Buffer } from "node:buffer";
+import { randomUUID } from "crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import lockfile from "proper-lockfile";
+import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
+import { writeDurableAtomicFileSync } from "../utils/durable-atomic-write.js";
+import { normalizePath, resolvePath } from "../utils/paths.js";
+import { ensurePrivateDirectorySync, hardenPrivateRegularFileSync } from "../utils/private-files.js";
+import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
+/** Deep merge records: overrides take precedence, nested objects merge recursively, arrays replace. */
+function deepMergeRecord(base, overrides) {
+    const result = { ...base };
+    for (const [key, overrideValue] of Object.entries(overrides)) {
+        if (overrideValue === undefined) {
+            continue;
+        }
+        if (overrideValue === null) {
+            delete result[key];
+            continue;
+        }
+        const baseValue = base[key];
+        if (isSettingsRecord(baseValue) && isSettingsRecord(overrideValue)) {
+            result[key] = deepMergeRecord(baseValue, overrideValue);
+        }
+        else {
+            result[key] = overrideValue;
+        }
+    }
+    return result;
+}
+/** Deep merge settings: project/overrides take precedence, nested objects merge recursively. */
+function deepMergeSettings(base, overrides) {
+    return deepMergeRecord(base, overrides);
+}
+function normalizeProfileName(profile) {
+    const trimmed = profile?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function isSettingsRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function defineOwnEnumerableProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+function normalizeProfileClears(profile) {
+    for (const key of Object.keys(profile)) {
+        const value = profile[key];
+        if (value === undefined) {
+            profile[key] = null;
+        }
+        else if (isSettingsRecord(value)) {
+            normalizeProfileClears(value);
+        }
+    }
+}
+function getOwnProfileSettings(settings, profileName) {
+    const profiles = settings.profiles;
+    if (!isSettingsRecord(profiles) || !Object.hasOwn(profiles, profileName)) {
+        return undefined;
+    }
+    const profile = profiles[profileName];
+    return isSettingsRecord(profile) ? profile : undefined;
+}
+function cloneProfiles(profiles) {
+    const cloned = {};
+    if (!isSettingsRecord(profiles)) {
+        return cloned;
+    }
+    for (const [profileName, profile] of Object.entries(profiles)) {
+        defineOwnEnumerableProperty(cloned, profileName, profile);
+    }
+    return cloned;
+}
+function sanitizeProfileSettings(profile) {
+    if (!profile) {
+        return {};
+    }
+    const sanitized = structuredClone(profile);
+    delete sanitized.lastChangelogVersion;
+    delete sanitized.defaultProfile;
+    delete sanitized.profiles;
+    delete sanitized.defaultProjectTrust;
+    delete sanitized.enableInstallTelemetry;
+    delete sanitized.enableAnalytics;
+    delete sanitized.trackingId;
+    delete sanitized.sessionDir;
+    delete sanitized.storage;
+    return sanitized;
+}
+function parseTimeoutSetting(value, settingName) {
+    const timeoutMs = parseHttpIdleTimeoutMs(value);
+    if (timeoutMs !== undefined) {
+        return timeoutMs;
+    }
+    if (value !== undefined) {
+        throw new Error(`Invalid ${settingName} setting: ${String(value)}`);
+    }
+    return undefined;
+}
+export class FileSettingsStorage {
+    static MAX_SETTINGS_BYTES = 4 * 1024 * 1024;
+    globalSettingsPath;
+    projectSettingsPath;
+    constructor(cwd, agentDir) {
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        this.globalSettingsPath = join(resolvedAgentDir, "settings.json");
+        this.projectSettingsPath = join(resolvedCwd, CONFIG_DIR_NAME, "settings.json");
+    }
+    acquireLockSyncWithRetry(path) {
+        const maxAttempts = 10;
+        const delayMs = 20;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return lockfile.lockSync(path, { realpath: false });
+            }
+            catch (error) {
+                const code = typeof error === "object" && error !== null && "code" in error
+                    ? String(error.code)
+                    : undefined;
+                if (code !== "ELOCKED" || attempt === maxAttempts) {
+                    throw error;
+                }
+                lastError = error;
+                const start = Date.now();
+                while (Date.now() - start < delayMs) {
+                    // Sleep synchronously to avoid changing callers to async.
+                }
+            }
+        }
+        throw lastError ?? new Error("Failed to acquire settings lock");
+    }
+    prepareDirectory(scope, directoryPath) {
+        if (scope === "global") {
+            ensurePrivateDirectorySync(directoryPath);
+            return;
+        }
+        mkdirSync(directoryPath, { recursive: true, mode: 0o755 });
+        const stat = lstatSync(directoryPath);
+        if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            throw new Error(`Refusing to use non-directory project settings path: ${directoryPath}`);
+        }
+    }
+    readCurrent(scope, path) {
+        if (!existsSync(path))
+            return undefined;
+        if (scope === "global") {
+            hardenPrivateRegularFileSync(path);
+        }
+        else {
+            const stat = lstatSync(path);
+            if (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1) {
+                throw new Error(`Refusing to use non-regular project settings file: ${path}`);
+            }
+        }
+        if (lstatSync(path).size > FileSettingsStorage.MAX_SETTINGS_BYTES) {
+            throw new Error(`Settings file exceeds ${FileSettingsStorage.MAX_SETTINGS_BYTES} bytes: ${path}`);
+        }
+        return readFileSync(path, "utf-8");
+    }
+    writeNext(scope, path, next) {
+        if (Buffer.byteLength(next, "utf8") > FileSettingsStorage.MAX_SETTINGS_BYTES) {
+            throw new Error(`Refusing to write settings larger than ${FileSettingsStorage.MAX_SETTINGS_BYTES} bytes`);
+        }
+        writeDurableAtomicFileSync(path, next, {
+            directoryMode: scope === "global" ? 0o700 : 0o755,
+            fileMode: scope === "global" ? 0o600 : 0o644,
+        });
+    }
+    withLock(scope, fn) {
+        const path = scope === "global" ? this.globalSettingsPath : this.projectSettingsPath;
+        const dir = dirname(path);
+        let release;
+        try {
+            if (existsSync(path)) {
+                this.prepareDirectory(scope, dir);
+                release = this.acquireLockSyncWithRetry(path);
+                const next = fn(this.readCurrent(scope, path));
+                if (next !== undefined)
+                    this.writeNext(scope, path, next);
+                return;
+            }
+            const initialNext = fn(undefined);
+            if (initialNext === undefined)
+                return;
+            this.prepareDirectory(scope, dir);
+            release = this.acquireLockSyncWithRetry(path);
+            const current = this.readCurrent(scope, path);
+            const next = current === undefined ? initialNext : fn(current);
+            if (next !== undefined)
+                this.writeNext(scope, path, next);
+        }
+        finally {
+            if (release) {
+                release();
+            }
+        }
+    }
+}
+export class InMemorySettingsStorage {
+    global;
+    project;
+    withLock(scope, fn) {
+        const current = scope === "global" ? this.global : this.project;
+        const next = fn(current);
+        if (next !== undefined) {
+            if (scope === "global") {
+                this.global = next;
+            }
+            else {
+                this.project = next;
+            }
+        }
+    }
+}
+export class SettingsManager {
+    storage;
+    globalSettings;
+    projectSettings;
+    globalEffectiveSettings = {};
+    projectEffectiveSettings = {};
+    settings = {};
+    requestedProfile;
+    activeProfile;
+    reportedMissingProfiles = new Set();
+    projectTrusted;
+    modifiedFields = new Set(); // Track global fields modified during session
+    modifiedNestedFields = new Map(); // Track global nested field modifications
+    modifiedProfileFields = new Map(); // Track global profile field modifications
+    modifiedProfileNestedFields = new Map(); // Track global profile nested field modifications
+    modifiedProjectFields = new Set(); // Track project fields modified during session
+    modifiedProjectNestedFields = new Map(); // Track project nested field modifications
+    modifiedProjectProfileFields = new Map(); // Track project profile field modifications
+    modifiedProjectProfileNestedFields = new Map(); // Track project profile nested field modifications
+    globalSettingsLoadError = null; // Track if global settings file had parse errors
+    projectSettingsLoadError = null; // Track if project settings file had parse errors
+    writeQueue = Promise.resolve();
+    errors;
+    sessionOverrides = {}; // Runtime overrides (e.g. CLI flags), reapplied on every re-merge
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true, profile) {
+        this.storage = storage;
+        this.globalSettings = initialGlobal;
+        this.projectSettings = initialProject;
+        this.projectTrusted = projectTrusted;
+        this.requestedProfile = normalizeProfileName(profile);
+        this.globalSettingsLoadError = globalLoadError;
+        this.projectSettingsLoadError = projectLoadError;
+        this.errors = [...initialErrors];
+        this.mergeEffectiveSettings();
+    }
+    getProfileOverlay(settings, profileName) {
+        if (!profileName) {
+            return {};
+        }
+        return sanitizeProfileSettings(getOwnProfileSettings(settings, profileName));
+    }
+    applyProfile(settings, profileName) {
+        return deepMergeSettings(settings, this.getProfileOverlay(settings, profileName));
+    }
+    reportMissingProfile(profileName) {
+        if (!this.projectTrusted || this.reportedMissingProfiles.has(profileName)) {
+            return;
+        }
+        if (getOwnProfileSettings(this.globalSettings, profileName) ||
+            getOwnProfileSettings(this.projectSettings, profileName)) {
+            return;
+        }
+        this.reportedMissingProfiles.add(profileName);
+        this.recordError("global", new Error(`Profile "${profileName}" was selected but is not defined`));
+    }
+    /** Re-merge effective settings from global, project, profile overlays, and session overrides */
+    mergeEffectiveSettings() {
+        const baseSettings = deepMergeSettings(this.globalSettings, this.projectSettings);
+        const profileName = this.requestedProfile ?? normalizeProfileName(baseSettings.defaultProfile);
+        this.activeProfile = profileName;
+        this.globalEffectiveSettings = this.applyProfile(this.globalSettings, profileName);
+        const projectProfileOverlay = this.projectTrusted
+            ? this.getProfileOverlay(this.projectSettings, profileName)
+            : {};
+        this.projectEffectiveSettings = this.projectTrusted
+            ? deepMergeSettings(this.projectSettings, projectProfileOverlay)
+            : {};
+        let merged = deepMergeSettings(this.globalEffectiveSettings, this.projectTrusted ? this.projectSettings : {});
+        merged = deepMergeSettings(merged, projectProfileOverlay);
+        if (Object.keys(this.sessionOverrides).length > 0) {
+            merged = deepMergeSettings(merged, this.sessionOverrides);
+        }
+        this.settings = merged;
+        if (profileName) {
+            this.reportMissingProfile(profileName);
+        }
+    }
+    /** Create a SettingsManager that loads from files */
+    static create(cwd, agentDir = getAgentDir(), options = {}) {
+        const storage = new FileSettingsStorage(cwd, agentDir);
+        return SettingsManager.fromStorage(storage, options);
+    }
+    /** Create a SettingsManager from an arbitrary storage backend */
+    static fromStorage(storage, options = {}) {
+        const projectTrusted = options.projectTrusted ?? true;
+        const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
+        const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project", projectTrusted);
+        const initialErrors = [];
+        if (globalLoad.error) {
+            initialErrors.push({ scope: "global", error: globalLoad.error });
+        }
+        if (projectLoad.error) {
+            initialErrors.push({ scope: "project", error: projectLoad.error });
+        }
+        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted, options.profile);
+    }
+    /** Create an in-memory SettingsManager (no file I/O) */
+    static inMemory(settings = {}, options = {}) {
+        const storage = new InMemorySettingsStorage();
+        const initialSettings = SettingsManager.migrateSettings(structuredClone(settings));
+        storage.withLock("global", () => JSON.stringify(initialSettings, null, 2));
+        return SettingsManager.fromStorage(storage, options);
+    }
+    static loadFromStorage(storage, scope, projectTrusted = true) {
+        if (scope === "project" && !projectTrusted) {
+            return {};
+        }
+        let content;
+        storage.withLock(scope, (current) => {
+            content = current;
+            return undefined;
+        });
+        if (!content) {
+            return {};
+        }
+        const settings = JSON.parse(content);
+        return SettingsManager.migrateSettings(settings);
+    }
+    static tryLoadFromStorage(storage, scope, projectTrusted = true) {
+        try {
+            return { settings: SettingsManager.loadFromStorage(storage, scope, projectTrusted), error: null };
+        }
+        catch (error) {
+            return { settings: {}, error: error };
+        }
+    }
+    /** Migrate old settings format to new format */
+    static migrateSettings(settings) {
+        // Migrate queueMode -> steeringMode
+        if ("queueMode" in settings && !("steeringMode" in settings)) {
+            settings.steeringMode = settings.queueMode;
+            delete settings.queueMode;
+        }
+        // Migrate legacy websockets boolean -> transport enum
+        if (!("transport" in settings) && typeof settings.websockets === "boolean") {
+            settings.transport = settings.websockets ? "websocket" : "sse";
+            delete settings.websockets;
+        }
+        // Migrate old skills object format to new array format
+        if ("skills" in settings &&
+            typeof settings.skills === "object" &&
+            settings.skills !== null &&
+            !Array.isArray(settings.skills)) {
+            const skillsSettings = settings.skills;
+            if (skillsSettings.enableSkillCommands !== undefined && settings.enableSkillCommands === undefined) {
+                settings.enableSkillCommands = skillsSettings.enableSkillCommands;
+            }
+            if (Array.isArray(skillsSettings.customDirectories) && skillsSettings.customDirectories.length > 0) {
+                settings.skills = skillsSettings.customDirectories;
+            }
+            else {
+                delete settings.skills;
+            }
+        }
+        // Migrate retry.maxDelayMs -> retry.provider.maxRetryDelayMs
+        if ("retry" in settings &&
+            typeof settings.retry === "object" &&
+            settings.retry !== null &&
+            !Array.isArray(settings.retry)) {
+            const retrySettings = settings.retry;
+            const providerSettings = typeof retrySettings.provider === "object" && retrySettings.provider !== null
+                ? retrySettings.provider
+                : undefined;
+            if (typeof retrySettings.maxDelayMs === "number" &&
+                (providerSettings?.maxRetryDelayMs === undefined || providerSettings?.maxRetryDelayMs === null)) {
+                retrySettings.provider = {
+                    ...(providerSettings ?? {}),
+                    maxRetryDelayMs: retrySettings.maxDelayMs,
+                };
+            }
+            delete retrySettings.maxDelayMs;
+        }
+        return settings;
+    }
+    getGlobalSettings() {
+        return structuredClone(this.globalSettings);
+    }
+    getProjectSettings() {
+        return structuredClone(this.projectSettings);
+    }
+    getGlobalEffectiveSettings() {
+        return structuredClone(this.globalEffectiveSettings);
+    }
+    getProjectEffectiveSettings() {
+        return structuredClone(this.projectEffectiveSettings);
+    }
+    getActiveProfile() {
+        return this.activeProfile;
+    }
+    getRequestedProfile() {
+        return this.requestedProfile;
+    }
+    getProfileNames() {
+        const names = new Set();
+        const addProfileNames = (profiles) => {
+            if (!isSettingsRecord(profiles)) {
+                return;
+            }
+            for (const [profileName, profile] of Object.entries(profiles)) {
+                if (isSettingsRecord(profile)) {
+                    names.add(profileName);
+                }
+            }
+        };
+        addProfileNames(this.globalSettings.profiles);
+        if (this.projectTrusted) {
+            addProfileNames(this.projectSettings.profiles);
+        }
+        return [...names].sort((a, b) => a.localeCompare(b));
+    }
+    hasProfile(profile) {
+        const profileName = normalizeProfileName(profile);
+        if (!profileName) {
+            return false;
+        }
+        return (getOwnProfileSettings(this.globalSettings, profileName) !== undefined ||
+            (this.projectTrusted && getOwnProfileSettings(this.projectSettings, profileName) !== undefined));
+    }
+    ensureGlobalProfile(profile) {
+        const profileName = normalizeProfileName(profile);
+        if (!profileName) {
+            throw new Error("Profile name cannot be empty");
+        }
+        if (getOwnProfileSettings(this.globalSettings, profileName)) {
+            return profileName;
+        }
+        this.globalSettings.profiles = cloneProfiles(this.globalSettings.profiles);
+        defineOwnEnumerableProperty(this.globalSettings.profiles, profileName, {});
+        this.markProfileModified(profileName);
+        this.save();
+        return profileName;
+    }
+    setActiveProfile(profile) {
+        this.requestedProfile = normalizeProfileName(profile);
+        this.reportedMissingProfiles.clear();
+        this.mergeEffectiveSettings();
+    }
+    rememberActiveProfile() {
+        if (!this.activeProfile || getOwnProfileSettings(this.globalSettings, this.activeProfile) === undefined) {
+            return;
+        }
+        if (normalizeProfileName(this.globalSettings.defaultProfile) === this.activeProfile) {
+            return;
+        }
+        this.globalSettings.defaultProfile = this.activeProfile;
+        this.markModified("defaultProfile");
+        this.save();
+    }
+    isProjectTrusted() {
+        return this.projectTrusted;
+    }
+    setProjectTrusted(trusted) {
+        if (this.projectTrusted === trusted) {
+            return;
+        }
+        this.projectTrusted = trusted;
+        this.modifiedProjectFields.clear();
+        this.modifiedProjectNestedFields.clear();
+        this.modifiedProjectProfileFields.clear();
+        this.modifiedProjectProfileNestedFields.clear();
+        if (!trusted) {
+            this.projectSettings = {};
+            this.projectSettingsLoadError = null;
+            this.mergeEffectiveSettings();
+            return;
+        }
+        const projectLoad = SettingsManager.tryLoadFromStorage(this.storage, "project", trusted);
+        this.projectSettings = projectLoad.settings;
+        this.projectSettingsLoadError = projectLoad.error;
+        if (projectLoad.error) {
+            this.recordError("project", projectLoad.error);
+        }
+        this.mergeEffectiveSettings();
+    }
+    async reload() {
+        await this.writeQueue;
+        const globalLoad = SettingsManager.tryLoadFromStorage(this.storage, "global");
+        if (!globalLoad.error) {
+            this.globalSettings = globalLoad.settings;
+            this.globalSettingsLoadError = null;
+        }
+        else {
+            this.globalSettingsLoadError = globalLoad.error;
+            this.recordError("global", globalLoad.error);
+        }
+        this.modifiedFields.clear();
+        this.modifiedNestedFields.clear();
+        this.modifiedProfileFields.clear();
+        this.modifiedProfileNestedFields.clear();
+        this.modifiedProjectFields.clear();
+        this.modifiedProjectNestedFields.clear();
+        this.modifiedProjectProfileFields.clear();
+        this.modifiedProjectProfileNestedFields.clear();
+        const projectLoad = SettingsManager.tryLoadFromStorage(this.storage, "project", this.projectTrusted);
+        if (!projectLoad.error) {
+            this.projectSettings = projectLoad.settings;
+            this.projectSettingsLoadError = null;
+        }
+        else {
+            this.projectSettingsLoadError = projectLoad.error;
+            this.recordError("project", projectLoad.error);
+        }
+        this.mergeEffectiveSettings();
+    }
+    /** Apply additional overrides on top of current settings. Overrides persist across reload() and re-merges. */
+    applyOverrides(overrides) {
+        this.sessionOverrides = deepMergeSettings(this.sessionOverrides, overrides);
+        this.mergeEffectiveSettings();
+    }
+    /** Mark a global field as modified during this session */
+    markModified(field, nestedKey) {
+        this.modifiedFields.add(field);
+        if (nestedKey) {
+            if (!this.modifiedNestedFields.has(field)) {
+                this.modifiedNestedFields.set(field, new Set());
+            }
+            this.modifiedNestedFields.get(field).add(nestedKey);
+        }
+    }
+    /** Mark a project field as modified during this session */
+    markProjectModified(field, nestedKey) {
+        this.modifiedProjectFields.add(field);
+        if (nestedKey) {
+            if (!this.modifiedProjectNestedFields.has(field)) {
+                this.modifiedProjectNestedFields.set(field, new Set());
+            }
+            this.modifiedProjectNestedFields.get(field).add(nestedKey);
+        }
+    }
+    trackProfileNestedField(modifiedNestedFields, profileName, field, nestedKey) {
+        let profileNestedFields = modifiedNestedFields.get(profileName);
+        if (!profileNestedFields) {
+            profileNestedFields = new Map();
+            modifiedNestedFields.set(profileName, profileNestedFields);
+        }
+        if (!profileNestedFields.has(field)) {
+            profileNestedFields.set(field, new Set());
+        }
+        profileNestedFields.get(field).add(nestedKey);
+    }
+    markProfileModified(profileName, field, nestedKey) {
+        this.modifiedFields.add("profiles");
+        if (!this.modifiedProfileFields.has(profileName)) {
+            this.modifiedProfileFields.set(profileName, new Set());
+        }
+        if (field !== undefined) {
+            this.modifiedProfileFields.get(profileName).add(field);
+            if (nestedKey) {
+                this.trackProfileNestedField(this.modifiedProfileNestedFields, profileName, field, nestedKey);
+            }
+        }
+    }
+    markProjectProfileModified(profileName, field, nestedKey) {
+        this.modifiedProjectFields.add("profiles");
+        if (!this.modifiedProjectProfileFields.has(profileName)) {
+            this.modifiedProjectProfileFields.set(profileName, new Set());
+        }
+        this.modifiedProjectProfileFields.get(profileName).add(field);
+        if (nestedKey) {
+            this.trackProfileNestedField(this.modifiedProjectProfileNestedFields, profileName, field, nestedKey);
+        }
+    }
+    assertProjectTrustedForWrite() {
+        if (!this.projectTrusted) {
+            throw new Error("Project is not trusted; refusing to write project settings");
+        }
+    }
+    recordError(scope, error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.errors.push({ scope, error: normalizedError });
+    }
+    clearModifiedScope(scope) {
+        if (scope === "global") {
+            this.modifiedFields.clear();
+            this.modifiedNestedFields.clear();
+            this.modifiedProfileFields.clear();
+            this.modifiedProfileNestedFields.clear();
+            return;
+        }
+        this.modifiedProjectFields.clear();
+        this.modifiedProjectNestedFields.clear();
+        this.modifiedProjectProfileFields.clear();
+        this.modifiedProjectProfileNestedFields.clear();
+    }
+    enqueueWrite(scope, task) {
+        this.writeQueue = this.writeQueue
+            .then(() => {
+            if (scope === "project") {
+                this.assertProjectTrustedForWrite();
+            }
+            task();
+            this.clearModifiedScope(scope);
+        })
+            .catch((error) => {
+            this.recordError(scope, error);
+        });
+    }
+    cloneModifiedNestedFields(source) {
+        const snapshot = new Map();
+        for (const [key, value] of source.entries()) {
+            snapshot.set(key, new Set(value));
+        }
+        return snapshot;
+    }
+    cloneModifiedProfileFields(source) {
+        const snapshot = new Map();
+        for (const [profileName, fields] of source.entries()) {
+            snapshot.set(profileName, new Set(fields));
+        }
+        return snapshot;
+    }
+    cloneModifiedProfileNestedFields(source) {
+        const snapshot = new Map();
+        for (const [profileName, profileNestedFields] of source.entries()) {
+            const clonedNestedFields = new Map();
+            for (const [field, nestedFields] of profileNestedFields.entries()) {
+                clonedNestedFields.set(field, new Set(nestedFields));
+            }
+            snapshot.set(profileName, clonedNestedFields);
+        }
+        return snapshot;
+    }
+    persistScopedSettings(scope, snapshotSettings, modifiedFields, modifiedNestedFields, modifiedProfileFields, modifiedProfileNestedFields) {
+        this.storage.withLock(scope, (current) => {
+            const currentFileSettings = current
+                ? SettingsManager.migrateSettings(JSON.parse(current))
+                : {};
+            const mergedSettings = { ...currentFileSettings };
+            for (const field of modifiedFields) {
+                const value = snapshotSettings[field];
+                if (field === "profiles" && modifiedProfileFields.size > 0) {
+                    const currentProfiles = isSettingsRecord(currentFileSettings.profiles)
+                        ? currentFileSettings.profiles
+                        : {};
+                    const snapshotProfiles = isSettingsRecord(snapshotSettings.profiles) ? snapshotSettings.profiles : {};
+                    const mergedProfiles = {};
+                    for (const [profileName, profile] of Object.entries(currentProfiles)) {
+                        defineOwnEnumerableProperty(mergedProfiles, profileName, profile);
+                    }
+                    for (const [profileName, profileFields] of modifiedProfileFields.entries()) {
+                        const currentProfile = Object.hasOwn(currentProfiles, profileName) && isSettingsRecord(currentProfiles[profileName])
+                            ? currentProfiles[profileName]
+                            : {};
+                        const snapshotProfile = Object.hasOwn(snapshotProfiles, profileName) && isSettingsRecord(snapshotProfiles[profileName])
+                            ? snapshotProfiles[profileName]
+                            : {};
+                        if (profileFields.size === 0) {
+                            defineOwnEnumerableProperty(mergedProfiles, profileName, snapshotProfile);
+                            continue;
+                        }
+                        const mergedProfile = {};
+                        const profileNestedFields = modifiedProfileNestedFields.get(profileName);
+                        for (const [profileField, profileValue] of Object.entries(currentProfile)) {
+                            defineOwnEnumerableProperty(mergedProfile, profileField, profileValue);
+                        }
+                        for (const profileField of profileFields) {
+                            const nestedModified = profileNestedFields?.get(profileField);
+                            const snapshotValue = snapshotProfile[profileField];
+                            if (nestedModified && isSettingsRecord(snapshotValue)) {
+                                const baseNested = isSettingsRecord(currentProfile[profileField])
+                                    ? currentProfile[profileField]
+                                    : {};
+                                const mergedNested = { ...baseNested };
+                                for (const nestedKey of nestedModified) {
+                                    mergedNested[nestedKey] = snapshotValue[nestedKey];
+                                }
+                                defineOwnEnumerableProperty(mergedProfile, profileField, mergedNested);
+                            }
+                            else {
+                                defineOwnEnumerableProperty(mergedProfile, profileField, snapshotValue);
+                            }
+                        }
+                        defineOwnEnumerableProperty(mergedProfiles, profileName, mergedProfile);
+                    }
+                    mergedSettings.profiles = mergedProfiles;
+                }
+                else if (modifiedNestedFields.has(field) && isSettingsRecord(value)) {
+                    const nestedModified = modifiedNestedFields.get(field);
+                    const baseNested = isSettingsRecord(currentFileSettings[field]) ? currentFileSettings[field] : {};
+                    const mergedNested = { ...baseNested };
+                    for (const nestedKey of nestedModified) {
+                        mergedNested[nestedKey] = value[nestedKey];
+                    }
+                    mergedSettings[field] = mergedNested;
+                }
+                else {
+                    mergedSettings[field] = value;
+                }
+            }
+            return JSON.stringify(mergedSettings, null, 2);
+        });
+    }
+    save() {
+        this.mergeEffectiveSettings();
+        if (this.globalSettingsLoadError) {
+            return;
+        }
+        const snapshotGlobalSettings = structuredClone(this.globalSettings);
+        const modifiedFields = new Set(this.modifiedFields);
+        const modifiedNestedFields = this.cloneModifiedNestedFields(this.modifiedNestedFields);
+        const modifiedProfileFields = this.cloneModifiedProfileFields(this.modifiedProfileFields);
+        const modifiedProfileNestedFields = this.cloneModifiedProfileNestedFields(this.modifiedProfileNestedFields);
+        this.enqueueWrite("global", () => {
+            this.persistScopedSettings("global", snapshotGlobalSettings, modifiedFields, modifiedNestedFields, modifiedProfileFields, modifiedProfileNestedFields);
+        });
+    }
+    saveProjectSettings(settings) {
+        this.assertProjectTrustedForWrite();
+        this.projectSettings = structuredClone(settings);
+        this.mergeEffectiveSettings();
+        if (this.projectSettingsLoadError) {
+            return;
+        }
+        const snapshotProjectSettings = structuredClone(this.projectSettings);
+        const modifiedFields = new Set(this.modifiedProjectFields);
+        const modifiedNestedFields = this.cloneModifiedNestedFields(this.modifiedProjectNestedFields);
+        const modifiedProfileFields = this.cloneModifiedProfileFields(this.modifiedProjectProfileFields);
+        const modifiedProfileNestedFields = this.cloneModifiedProfileNestedFields(this.modifiedProjectProfileNestedFields);
+        this.enqueueWrite("project", () => {
+            this.persistScopedSettings("project", snapshotProjectSettings, modifiedFields, modifiedNestedFields, modifiedProfileFields, modifiedProfileNestedFields);
+        });
+    }
+    updateProfileSettings(settings, profileName, update) {
+        settings.profiles = cloneProfiles(settings.profiles);
+        const profileSettings = structuredClone(getOwnProfileSettings(settings, profileName) ?? {});
+        update(profileSettings);
+        normalizeProfileClears(profileSettings);
+        defineOwnEnumerableProperty(settings.profiles, profileName, profileSettings);
+    }
+    updateGlobalSettings(field, update, nestedKey) {
+        this.updateGlobalSettingsFields([{ field, nestedKey }], update);
+    }
+    updateGlobalSettingsFields(modifiedSettings, update) {
+        if (this.activeProfile) {
+            this.updateProfileSettings(this.globalSettings, this.activeProfile, update);
+            for (const modifiedSetting of modifiedSettings) {
+                this.markProfileModified(this.activeProfile, modifiedSetting.field, modifiedSetting.nestedKey);
+            }
+        }
+        else {
+            update(this.globalSettings);
+            for (const modifiedSetting of modifiedSettings) {
+                this.markModified(modifiedSetting.field, modifiedSetting.nestedKey);
+            }
+        }
+        this.save();
+    }
+    updateProjectSettings(field, update, nestedKey) {
+        this.updateProjectSettingsFields([{ field, nestedKey }], update);
+    }
+    updateProjectSettingsFields(modifiedSettings, update) {
+        this.assertProjectTrustedForWrite();
+        const projectSettings = structuredClone(this.projectSettings);
+        if (this.activeProfile) {
+            this.updateProfileSettings(projectSettings, this.activeProfile, update);
+            for (const modifiedSetting of modifiedSettings) {
+                this.markProjectProfileModified(this.activeProfile, modifiedSetting.field, modifiedSetting.nestedKey);
+            }
+        }
+        else {
+            update(projectSettings);
+            for (const modifiedSetting of modifiedSettings) {
+                this.markProjectModified(modifiedSetting.field, modifiedSetting.nestedKey);
+            }
+        }
+        this.saveProjectSettings(projectSettings);
+    }
+    async flush() {
+        await this.writeQueue;
+    }
+    drainErrors() {
+        const drained = [...this.errors];
+        this.errors = [];
+        return drained;
+    }
+    getLastChangelogVersion() {
+        return this.settings.lastChangelogVersion;
+    }
+    setLastChangelogVersion(version) {
+        this.globalSettings.lastChangelogVersion = version;
+        this.markModified("lastChangelogVersion");
+        this.save();
+    }
+    getSessionDir() {
+        const sessionDir = this.settings.sessionDir;
+        return sessionDir ? normalizePath(sessionDir) : sessionDir;
+    }
+    getDefaultProvider() {
+        return this.settings.defaultProvider;
+    }
+    getDefaultModel() {
+        return this.settings.defaultModel;
+    }
+    setDefaultProvider(provider) {
+        this.updateGlobalSettings("defaultProvider", (settings) => {
+            settings.defaultProvider = provider;
+        });
+    }
+    setDefaultModel(modelId) {
+        this.updateGlobalSettings("defaultModel", (settings) => {
+            settings.defaultModel = modelId;
+        });
+    }
+    setDefaultModelAndProvider(provider, modelId) {
+        this.updateGlobalSettingsFields([{ field: "defaultProvider" }, { field: "defaultModel" }], (settings) => {
+            settings.defaultProvider = provider;
+            settings.defaultModel = modelId;
+        });
+    }
+    getSteeringMode() {
+        return this.settings.steeringMode || "one-at-a-time";
+    }
+    setSteeringMode(mode) {
+        this.updateGlobalSettings("steeringMode", (settings) => {
+            settings.steeringMode = mode;
+        });
+    }
+    getFollowUpMode() {
+        return this.settings.followUpMode || "one-at-a-time";
+    }
+    setFollowUpMode(mode) {
+        this.updateGlobalSettings("followUpMode", (settings) => {
+            settings.followUpMode = mode;
+        });
+    }
+    getTheme() {
+        return this.settings.theme;
+    }
+    setTheme(theme) {
+        this.updateGlobalSettings("theme", (settings) => {
+            settings.theme = theme;
+        });
+    }
+    getDefaultThinkingLevel() {
+        return this.settings.defaultThinkingLevel;
+    }
+    setDefaultThinkingLevel(level) {
+        this.updateGlobalSettings("defaultThinkingLevel", (settings) => {
+            settings.defaultThinkingLevel = level;
+        });
+    }
+    getTransport() {
+        return this.settings.transport ?? "auto";
+    }
+    setTransport(transport) {
+        this.updateGlobalSettings("transport", (settings) => {
+            settings.transport = transport;
+        });
+    }
+    getCompactionEnabled() {
+        return this.settings.compaction?.enabled ?? true;
+    }
+    setCompactionEnabled(enabled) {
+        this.updateGlobalSettings("compaction", (settings) => {
+            if (!settings.compaction) {
+                settings.compaction = {};
+            }
+            settings.compaction.enabled = enabled;
+        }, "enabled");
+    }
+    getCompactionReserveTokens() {
+        return this.settings.compaction?.reserveTokens ?? 16384;
+    }
+    getCompactionKeepRecentTokens() {
+        return this.settings.compaction?.keepRecentTokens ?? 20000;
+    }
+    getCompactionSettings() {
+        return {
+            enabled: this.getCompactionEnabled(),
+            reserveTokens: this.getCompactionReserveTokens(),
+            keepRecentTokens: this.getCompactionKeepRecentTokens(),
+        };
+    }
+    getBranchSummarySettings() {
+        return {
+            reserveTokens: this.settings.branchSummary?.reserveTokens ?? 16384,
+            skipPrompt: this.settings.branchSummary?.skipPrompt ?? false,
+        };
+    }
+    getBranchSummarySkipPrompt() {
+        return this.settings.branchSummary?.skipPrompt ?? false;
+    }
+    getRetryEnabled() {
+        return this.settings.retry?.enabled ?? true;
+    }
+    setRetryEnabled(enabled) {
+        this.updateGlobalSettings("retry", (settings) => {
+            if (!settings.retry) {
+                settings.retry = {};
+            }
+            settings.retry.enabled = enabled;
+        }, "enabled");
+    }
+    getRetrySettings() {
+        return {
+            enabled: this.getRetryEnabled(),
+            maxRetries: this.settings.retry?.maxRetries ?? 3,
+            baseDelayMs: this.settings.retry?.baseDelayMs ?? 2000,
+        };
+    }
+    getHttpIdleTimeoutMs() {
+        return parseTimeoutSetting(this.settings.httpIdleTimeoutMs, "httpIdleTimeoutMs") ?? DEFAULT_HTTP_IDLE_TIMEOUT_MS;
+    }
+    getRemoteSettings() {
+        return this.settings.remote ?? {};
+    }
+    setHttpIdleTimeoutMs(timeoutMs) {
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new Error(`Invalid httpIdleTimeoutMs setting: ${String(timeoutMs)}`);
+        }
+        this.updateGlobalSettings("httpIdleTimeoutMs", (settings) => {
+            settings.httpIdleTimeoutMs = Math.floor(timeoutMs);
+        });
+    }
+    getProviderRetrySettings() {
+        return {
+            timeoutMs: this.settings.retry?.provider?.timeoutMs,
+            maxRetries: this.settings.retry?.provider?.maxRetries,
+            maxRetryDelayMs: this.settings.retry?.provider?.maxRetryDelayMs ?? 60000,
+        };
+    }
+    getWebSocketConnectTimeoutMs() {
+        return parseTimeoutSetting(this.settings.websocketConnectTimeoutMs, "websocketConnectTimeoutMs");
+    }
+    getHideThinkingBlock() {
+        return this.settings.hideThinkingBlock ?? false;
+    }
+    setHideThinkingBlock(hide) {
+        this.updateGlobalSettings("hideThinkingBlock", (settings) => {
+            settings.hideThinkingBlock = hide;
+        });
+    }
+    getShellPath() {
+        return this.settings.shellPath;
+    }
+    setShellPath(path) {
+        this.updateGlobalSettings("shellPath", (settings) => {
+            settings.shellPath = path;
+        });
+    }
+    getQuietStartup() {
+        return this.settings.quietStartup ?? false;
+    }
+    setQuietStartup(quiet) {
+        this.updateGlobalSettings("quietStartup", (settings) => {
+            settings.quietStartup = quiet;
+        });
+    }
+    getDefaultProjectTrust() {
+        const value = this.globalSettings.defaultProjectTrust;
+        return value === "always" || value === "never" ? value : "ask";
+    }
+    setDefaultProjectTrust(defaultProjectTrust) {
+        this.globalSettings.defaultProjectTrust = defaultProjectTrust;
+        this.markModified("defaultProjectTrust");
+        this.save();
+    }
+    getShellCommandPrefix() {
+        return this.settings.shellCommandPrefix;
+    }
+    setShellCommandPrefix(prefix) {
+        this.updateGlobalSettings("shellCommandPrefix", (settings) => {
+            settings.shellCommandPrefix = prefix;
+        });
+    }
+    getNpmCommand() {
+        return this.settings.npmCommand ? [...this.settings.npmCommand] : undefined;
+    }
+    setNpmCommand(command) {
+        this.updateGlobalSettings("npmCommand", (settings) => {
+            settings.npmCommand = command ? [...command] : undefined;
+        });
+    }
+    getCollapseChangelog() {
+        return this.settings.collapseChangelog ?? false;
+    }
+    setCollapseChangelog(collapse) {
+        this.updateGlobalSettings("collapseChangelog", (settings) => {
+            settings.collapseChangelog = collapse;
+        });
+    }
+    getEnableInstallTelemetry() {
+        return this.settings.enableInstallTelemetry ?? true;
+    }
+    setEnableInstallTelemetry(enabled) {
+        this.globalSettings.enableInstallTelemetry = enabled;
+        this.markModified("enableInstallTelemetry");
+        this.save();
+    }
+    getEnableAnalytics() {
+        return this.settings.enableAnalytics ?? false;
+    }
+    getTrackingId() {
+        return this.settings.trackingId;
+    }
+    /** Set the analytics opt-in preference; generates a tracking identifier on first opt-in */
+    setEnableAnalytics(enabled) {
+        this.globalSettings.enableAnalytics = enabled;
+        this.markModified("enableAnalytics");
+        if (enabled && !this.globalSettings.trackingId) {
+            this.globalSettings.trackingId = randomUUID();
+            this.markModified("trackingId");
+        }
+        this.save();
+    }
+    getPackages() {
+        return [...(this.settings.packages ?? [])];
+    }
+    setPackages(packages) {
+        this.updateGlobalSettings("packages", (settings) => {
+            settings.packages = packages;
+        });
+    }
+    setProjectPackages(packages) {
+        this.updateProjectSettings("packages", (settings) => {
+            settings.packages = packages;
+        });
+    }
+    getExtensionPaths() {
+        return [...(this.settings.extensions ?? [])];
+    }
+    setExtensionPaths(paths) {
+        this.updateGlobalSettings("extensions", (settings) => {
+            settings.extensions = paths;
+        });
+    }
+    setProjectExtensionPaths(paths) {
+        this.updateProjectSettings("extensions", (settings) => {
+            settings.extensions = paths;
+        });
+    }
+    getSkillPaths() {
+        return [...(this.settings.skills ?? [])];
+    }
+    setSkillPaths(paths) {
+        this.updateGlobalSettings("skills", (settings) => {
+            settings.skills = paths;
+        });
+    }
+    setProjectSkillPaths(paths) {
+        this.updateProjectSettings("skills", (settings) => {
+            settings.skills = paths;
+        });
+    }
+    getPromptTemplatePaths() {
+        return [...(this.settings.prompts ?? [])];
+    }
+    setPromptTemplatePaths(paths) {
+        this.updateGlobalSettings("prompts", (settings) => {
+            settings.prompts = paths;
+        });
+    }
+    setProjectPromptTemplatePaths(paths) {
+        this.updateProjectSettings("prompts", (settings) => {
+            settings.prompts = paths;
+        });
+    }
+    getThemePaths() {
+        return [...(this.settings.themes ?? [])];
+    }
+    setThemePaths(paths) {
+        this.updateGlobalSettings("themes", (settings) => {
+            settings.themes = paths;
+        });
+    }
+    setProjectThemePaths(paths) {
+        this.updateProjectSettings("themes", (settings) => {
+            settings.themes = paths;
+        });
+    }
+    getEnableSkillCommands() {
+        return this.settings.enableSkillCommands ?? true;
+    }
+    setEnableSkillCommands(enabled) {
+        this.updateGlobalSettings("enableSkillCommands", (settings) => {
+            settings.enableSkillCommands = enabled;
+        });
+    }
+    getThinkingBudgets() {
+        return this.settings.thinkingBudgets;
+    }
+    getShowImages() {
+        return this.settings.terminal?.showImages ?? true;
+    }
+    setShowImages(show) {
+        this.updateGlobalSettings("terminal", (settings) => {
+            if (!settings.terminal) {
+                settings.terminal = {};
+            }
+            settings.terminal.showImages = show;
+        }, "showImages");
+    }
+    getImageWidthCells() {
+        const width = this.settings.terminal?.imageWidthCells;
+        if (typeof width !== "number" || !Number.isFinite(width)) {
+            return 60;
+        }
+        return Math.max(1, Math.floor(width));
+    }
+    setImageWidthCells(width) {
+        this.updateGlobalSettings("terminal", (settings) => {
+            if (!settings.terminal) {
+                settings.terminal = {};
+            }
+            settings.terminal.imageWidthCells = Math.max(1, Math.floor(width));
+        }, "imageWidthCells");
+    }
+    getClearOnShrink() {
+        // Settings takes precedence, then env var, then default false
+        if (this.settings.terminal?.clearOnShrink !== undefined) {
+            return this.settings.terminal.clearOnShrink;
+        }
+        return process.env.VOLT_CLEAR_ON_SHRINK === "1";
+    }
+    setClearOnShrink(enabled) {
+        this.updateGlobalSettings("terminal", (settings) => {
+            if (!settings.terminal) {
+                settings.terminal = {};
+            }
+            settings.terminal.clearOnShrink = enabled;
+        }, "clearOnShrink");
+    }
+    getShowTerminalProgress() {
+        return this.settings.terminal?.showTerminalProgress ?? false;
+    }
+    setShowTerminalProgress(enabled) {
+        this.updateGlobalSettings("terminal", (settings) => {
+            if (!settings.terminal) {
+                settings.terminal = {};
+            }
+            settings.terminal.showTerminalProgress = enabled;
+        }, "showTerminalProgress");
+    }
+    getTurnDoneAlert() {
+        const mode = this.settings.terminal?.turnDoneAlert;
+        return mode === "bell" || mode === "notify" ? mode : "off";
+    }
+    setTurnDoneAlert(mode) {
+        this.updateGlobalSettings("terminal", (settings) => {
+            if (!settings.terminal) {
+                settings.terminal = {};
+            }
+            settings.terminal.turnDoneAlert = mode;
+        }, "turnDoneAlert");
+    }
+    getImageAutoResize() {
+        return this.settings.images?.autoResize ?? true;
+    }
+    setImageAutoResize(enabled) {
+        this.updateGlobalSettings("images", (settings) => {
+            if (!settings.images) {
+                settings.images = {};
+            }
+            settings.images.autoResize = enabled;
+        }, "autoResize");
+    }
+    getBlockImages() {
+        return this.settings.images?.blockImages ?? false;
+    }
+    setBlockImages(blocked) {
+        this.updateGlobalSettings("images", (settings) => {
+            if (!settings.images) {
+                settings.images = {};
+            }
+            settings.images.blockImages = blocked;
+        }, "blockImages");
+    }
+    getEnabledModels() {
+        return this.settings.enabledModels;
+    }
+    getReviewModel() {
+        return this.settings.reviewModel;
+    }
+    setReviewModel(modelReference) {
+        this.updateGlobalSettings("reviewModel", (settings) => {
+            settings.reviewModel = modelReference;
+        });
+    }
+    getReviewTools() {
+        const tools = this.settings.reviewTools;
+        if (!Array.isArray(tools)) {
+            return undefined;
+        }
+        const normalized = tools.map((tool) => tool.trim()).filter(Boolean);
+        return normalized.length > 0 ? [...new Set(normalized)] : undefined;
+    }
+    setReviewTools(toolNames) {
+        this.updateGlobalSettings("reviewTools", (settings) => {
+            const normalized = toolNames?.map((tool) => tool.trim()).filter(Boolean) ?? [];
+            settings.reviewTools = normalized.length > 0 ? [...new Set(normalized)] : undefined;
+        });
+    }
+    setEnabledModels(patterns) {
+        this.updateGlobalSettings("enabledModels", (settings) => {
+            settings.enabledModels = patterns;
+        });
+    }
+    getDoubleEscapeAction() {
+        return this.settings.doubleEscapeAction ?? "tree";
+    }
+    setDoubleEscapeAction(action) {
+        this.updateGlobalSettings("doubleEscapeAction", (settings) => {
+            settings.doubleEscapeAction = action;
+        });
+    }
+    getTreeFilterMode() {
+        const mode = this.settings.treeFilterMode;
+        const valid = ["default", "no-tools", "user-only", "labeled-only", "all"];
+        return mode && valid.includes(mode) ? mode : "default";
+    }
+    setTreeFilterMode(mode) {
+        this.updateGlobalSettings("treeFilterMode", (settings) => {
+            settings.treeFilterMode = mode;
+        });
+    }
+    getShowHardwareCursor() {
+        return this.settings.showHardwareCursor ?? process.env.VOLT_HARDWARE_CURSOR === "1";
+    }
+    setShowHardwareCursor(enabled) {
+        this.updateGlobalSettings("showHardwareCursor", (settings) => {
+            settings.showHardwareCursor = enabled;
+        });
+    }
+    getEditorPaddingX() {
+        return this.settings.editorPaddingX ?? 0;
+    }
+    setEditorPaddingX(padding) {
+        this.updateGlobalSettings("editorPaddingX", (settings) => {
+            settings.editorPaddingX = Math.max(0, Math.min(3, Math.floor(padding)));
+        });
+    }
+    getAutocompleteMaxVisible() {
+        return this.settings.autocompleteMaxVisible ?? 5;
+    }
+    setAutocompleteMaxVisible(maxVisible) {
+        this.updateGlobalSettings("autocompleteMaxVisible", (settings) => {
+            settings.autocompleteMaxVisible = Math.max(3, Math.min(20, Math.floor(maxVisible)));
+        });
+    }
+    getCodeBlockIndent() {
+        return this.settings.markdown?.codeBlockIndent ?? "  ";
+    }
+    getLspSettings() {
+        return this.settings.lsp ? structuredClone(this.settings.lsp) : undefined;
+    }
+    getWarnings() {
+        return { ...(this.settings.warnings ?? {}) };
+    }
+    setWarnings(warnings) {
+        this.updateGlobalSettings("warnings", (settings) => {
+            settings.warnings = { ...warnings };
+        });
+    }
+}
+//# sourceMappingURL=settings-manager.js.map