@qduc/term2 0.9.3 → 0.10.0

package/dist/services/settings/settings-service.test.js

@@ -1,924 +0,0 @@
-import { it, expect, beforeAll, afterAll } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { SettingsService } from './settings-service.js';
-import { getProvider, getAllProviders } from '../../providers/index.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEST_BASE_DIR = path.join(__dirname, '../../test-settings');
-let testCounter = 0;
-// Helper to get unique settings directory per test
-const getTestSettingsDir = () => {
-    testCounter += 1;
-    return path.join(TEST_BASE_DIR, `test-${testCounter}`);
-};
-const getSettingsFilePath = (settingsDir) => path.join(settingsDir, 'settings.json');
-// AVA (and other runners) set environment variables that we use to detect a test environment.
-// Some tests need to validate the *non-test* behavior (i.e., persistence to disk).
-// We isolate those by temporarily clearing the test-runner env markers.
-async function withNonTestEnvironment(fn) {
-    const snapshot = {
-        NODE_ENV: process.env.NODE_ENV,
-        AVA_PATH: process.env.AVA_PATH,
-        JEST_WORKER_ID: process.env.JEST_WORKER_ID,
-        VITEST: process.env.VITEST,
-        TERM2_TEST_MODE: process.env.TERM2_TEST_MODE,
-    };
-    try {
-        // Ensure we do not look like a test environment to SettingsService.
-        // Setting NODE_ENV to a non-test value helps for setups that might default it.
-        process.env.NODE_ENV = 'production';
-        delete process.env.AVA_PATH;
-        delete process.env.JEST_WORKER_ID;
-        delete process.env.VITEST;
-        delete process.env.TERM2_TEST_MODE;
-        return await fn();
-    }
-    finally {
-        for (const [key, value] of Object.entries(snapshot)) {
-            if (value === undefined) {
-                delete process.env[key];
-            }
-            else {
-                process.env[key] = value;
-            }
-        }
-    }
-}
-// Helper to clean up test settings
-const cleanupSettings = () => {
-    if (fs.existsSync(TEST_BASE_DIR)) {
-        fs.rmSync(TEST_BASE_DIR, { recursive: true, force: true });
-    }
-};
-beforeAll(() => {
-    cleanupSettings();
-});
-afterAll(() => {
-    cleanupSettings();
-});
-it('SettingsService initializes with defaults', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(service).toBeTruthy();
-    expect(service.get('agent.model')).toBe('gpt-5.1');
-    expect(service.get('agent.reasoningEffort')).toBe('default');
-    expect(service.get('agent.temperature')).toBe(undefined);
-    expect(service.get('agent.maxTurns')).toBe(100);
-    expect(service.get('agent.retryAttempts')).toBe(2);
-    expect(service.get('agent.maxParallelToolCalls')).toBe(3);
-    expect(service.get('shell.timeout')).toBe(120000);
-    expect(service.get('shell.maxOutputLines')).toBe(1000);
-    expect(service.get('shell.maxOutputChars')).toBe(10000);
-    expect(service.get('ui.historySize')).toBe(1000);
-    expect(service.get('logging.logLevel')).toBe('info');
-});
-it('skips file writes in test environment (constructor + set)', async () => {
-    const settingsDir = getTestSettingsDir();
-    const settingsFile = getSettingsFilePath(settingsDir);
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(fs.existsSync(settingsFile)).toBe(false);
-    service.set('agent.model', 'gpt-4o');
-    expect(fs.existsSync(settingsFile)).toBe(false);
-});
-it.sequential('disableFilePersistence: true prevents writes even outside test environment', async () => {
-    await withNonTestEnvironment(async () => {
-        const settingsDir = getTestSettingsDir();
-        const settingsFile = getSettingsFilePath(settingsDir);
-        const service = new SettingsService({
-            settingsDir,
-            disableLogging: true,
-            disableFilePersistence: true,
-        });
-        expect(fs.existsSync(settingsFile)).toBe(false);
-        service.set('agent.model', 'gpt-4o');
-        expect(fs.existsSync(settingsFile)).toBe(false);
-    });
-});
-it.sequential('normal operation persists settings.json when not in test environment', async () => {
-    await withNonTestEnvironment(async () => {
-        const settingsDir = getTestSettingsDir();
-        const settingsFile = getSettingsFilePath(settingsDir);
-        const service = new SettingsService({
-            settingsDir,
-            disableLogging: true,
-        });
-        expect(fs.existsSync(settingsFile)).toBe(true);
-        service.set('agent.model', 'gpt-4o');
-        const content = fs.readFileSync(settingsFile, 'utf-8');
-        const config = JSON.parse(content);
-        expect(config.agent.model).toBe('gpt-4o');
-    });
-});
-it('creates settings directory if it does not exist', async () => {
-    const settingsDir = getTestSettingsDir();
-    new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(fs.existsSync(settingsDir)).toBe(true);
-});
-it('CLI overrides take highest precedence', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        cli: {
-            agent: {
-                model: 'gpt-4o',
-            },
-        },
-    });
-    expect(service.get('agent.model')).toBe('gpt-4o');
-    expect(service.getSource('agent.model')).toBe('cli');
-});
-it('env overrides config file but not CLI', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        agent: {
-            model: 'gpt-3.5-turbo',
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        env: {
-            agent: {
-                model: 'gpt-4-turbo',
-            },
-        },
-    });
-    expect(service.get('agent.model')).toBe('gpt-4-turbo');
-    expect(service.getSource('agent.model')).toBe('env');
-    // Now test with CLI override
-    const service2 = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        env: {
-            agent: {
-                model: 'gpt-4-turbo',
-            },
-        },
-        cli: {
-            agent: {
-                model: 'gpt-5.1',
-            },
-        },
-    });
-    expect(service2.get('agent.model')).toBe('gpt-5.1');
-    expect(service2.getSource('agent.model')).toBe('cli');
-});
-it('config file overrides defaults', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        shell: {
-            timeout: 60000,
-            maxOutputChars: 5000,
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(service.get('shell.timeout')).toBe(60000);
-    expect(service.get('shell.maxOutputChars')).toBe(5000);
-    expect(service.getSource('shell.timeout')).toBe('config');
-});
-it('registers custom OpenAI-compatible providers from settings.json', async () => {
-    const settingsDir = getTestSettingsDir();
-    const providerName = 'lmstudio-settings-service-test';
-    // TODO: // TODO: t.teardown(() => unregisterProvider(providerName)) needs manual try/finally conversion;
-    // Create a config file with providers
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        providers: [
-            {
-                name: providerName,
-                baseUrl: 'http://localhost:1234',
-                apiKey: 'my-secret-api-key',
-            },
-        ],
-        agent: {
-            provider: providerName,
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Provider should be registered and selectable
-    expect(getProvider(providerName)).toBeTruthy();
-    expect(getAllProviders().some((p) => p.id === providerName)).toBe(true);
-    expect(service.get('agent.provider')).toBe(providerName);
-});
-it('custom providers default missing type for old settings.json files', async () => {
-    const settingsDir = getTestSettingsDir();
-    const providerName = 'legacy-compatible-settings-service-test';
-    // TODO: // TODO: t.teardown(() => unregisterProvider(providerName)) needs manual try/finally conversion;
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        providers: [
-            {
-                name: providerName,
-                baseUrl: 'http://localhost:1234',
-            },
-        ],
-        agent: {
-            provider: providerName,
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        disableFilePersistence: true,
-    });
-    expect(service.get('providers')[0].type).toBe('openai-compatible');
-});
-it('set() modifies runtime-modifiable settings', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    service.set('agent.model', 'gpt-4o');
-    expect(service.get('agent.model')).toBe('gpt-4o');
-    expect(service.getSource('agent.model')).toBe('cli');
-    service.set('agent.temperature', 0.2);
-    expect(service.get('agent.temperature')).toBe(0.2);
-    expect(service.getSource('agent.temperature')).toBe('cli');
-    service.set('agent.maxParallelToolCalls', 5);
-    expect(service.get('agent.maxParallelToolCalls')).toBe(5);
-    expect(service.getSource('agent.maxParallelToolCalls')).toBe('cli');
-});
-it('set() throws for startup-only settings', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(() => {
-        service.set('agent.maxTurns', 30);
-    }).toThrow(/Cannot modify.*at runtime/);
-});
-it('setPersistent() saves startup-only settings after validating them', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        disableFilePersistence: true,
-    });
-    service.setPersistent('agent.maxTurns', 30);
-    expect(service.get('agent.maxTurns')).toBe(30);
-    expect(service.getSource('agent.maxTurns')).toBe('cli');
-});
-it('setPersistent() rejects invalid values', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        disableFilePersistence: true,
-    });
-    expect(() => {
-        service.setPersistent('agent.maxTurns', 0);
-    }).toThrow(/Invalid value for 'agent.maxTurns'/);
-});
-it('isRuntimeModifiable identifies correct settings', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Runtime-modifiable settings
-    expect(service.isRuntimeModifiable('agent.model')).toBe(true);
-    expect(service.isRuntimeModifiable('agent.reasoningEffort')).toBe(true);
-    expect(service.isRuntimeModifiable('agent.temperature')).toBe(true);
-    expect(service.isRuntimeModifiable('agent.retryAttempts')).toBe(true);
-    expect(service.isRuntimeModifiable('agent.maxParallelToolCalls')).toBe(true);
-    expect(service.isRuntimeModifiable('tools.editHealingModel')).toBe(true);
-    expect(service.isRuntimeModifiable('tools.editHealingProvider')).toBe(true);
-    expect(service.isRuntimeModifiable('shell.timeout')).toBe(true);
-    expect(service.isRuntimeModifiable('shell.maxOutputLines')).toBe(true);
-    expect(service.isRuntimeModifiable('shell.maxOutputChars')).toBe(true);
-    expect(service.isRuntimeModifiable('logging.logLevel')).toBe(true);
-    // Startup-only settings
-    expect(service.isRuntimeModifiable('agent.maxTurns')).toBe(false);
-    expect(service.isRuntimeModifiable('ui.historySize')).toBe(false);
-});
-it('reset() clones object defaults instead of reusing shared references', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    service.reset('agent.openrouter');
-    const firstResetValue = service.get('agent.openrouter');
-    firstResetValue.apiKey = 'mutated-secret';
-    service.reset('agent.openrouter');
-    const secondResetValue = service.get('agent.openrouter');
-    expect(secondResetValue).toEqual({});
-    expect(secondResetValue).not.toBe(firstResetValue);
-});
-it('reset() returns setting to default', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        shell: {
-            timeout: 60000,
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(service.get('shell.timeout')).toBe(60000);
-    service.reset('shell.timeout');
-    expect(service.get('shell.timeout')).toBe(120000);
-});
-it('getAll() returns all settings with sources', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        cli: {
-            agent: {
-                model: 'gpt-4o',
-            },
-        },
-    });
-    const all = service.getAll();
-    expect(all.agent).toBeTruthy();
-    expect(all.shell).toBeTruthy();
-    expect(all.ui).toBeTruthy();
-    expect(all.logging).toBeTruthy();
-    expect(all.agent.model.value).toBe('gpt-4o');
-    expect(all.agent.model.source).toBe('cli');
-    expect(all.agent.reasoningEffort.value).toBe('default');
-    expect(all.agent.reasoningEffort.source).toBe('default');
-    expect(all.agent.maxParallelToolCalls.value).toBe(3);
-    expect(all.agent.maxParallelToolCalls.source).toBe('default');
-});
-it('getAll() maps optional nested values and sources for agent.temperature and webSearch.tavily', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        env: {
-            webSearch: {
-                tavily: undefined,
-            },
-        },
-    });
-    const all = service.getAll();
-    expect(all.agent.temperature.value).toBe(undefined);
-    expect(all.agent.temperature.source).toBe('default');
-    expect(all.webSearch.tavily.value).toBe(undefined);
-    expect(all.webSearch.tavily.source).toBe('default');
-});
-it('SettingsService initialization applies logging.logLevel to loggingService', async () => {
-    const settingsDir = getTestSettingsDir();
-    const mockLoggingService = {
-        setLogLevel: (level) => {
-            mockLoggingService._level = level;
-        },
-        getLogLevel: () => mockLoggingService._level || 'info',
-        _level: 'info',
-    };
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        loggingService: mockLoggingService,
-        cli: {
-            logging: { logLevel: 'debug' },
-        },
-    });
-    expect(service.get('logging.logLevel')).toBe('debug');
-    expect(mockLoggingService.getLogLevel()).toBe('debug');
-});
-it('SettingsService runtime set updates loggingService', async () => {
-    const settingsDir = getTestSettingsDir();
-    const mockLoggingService = {
-        setLogLevel: (level) => {
-            mockLoggingService._level = level;
-        },
-        getLogLevel: () => mockLoggingService._level || 'info',
-        _level: 'info',
-    };
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        loggingService: mockLoggingService,
-    });
-    // Initially default
-    expect(service.get('logging.logLevel')).toBe('info');
-    service.set('logging.logLevel', 'debug');
-    expect(service.get('logging.logLevel')).toBe('debug');
-    expect(mockLoggingService.getLogLevel()).toBe('debug');
-});
-it('gracefully degrades on invalid config file', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create an invalid config file
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, 'invalid json {', 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Should load defaults and not throw
-    expect(service.get('agent.model')).toBe('gpt-5.1');
-});
-it('gracefully degrades on invalid schema in config file', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file with invalid values
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        shell: {
-            timeout: -100, // invalid: negative
-            maxOutputChars: 'not a number', // invalid
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Should fall back to defaults for invalid settings
-    expect(service.get('shell.timeout')).toBe(120000);
-    expect(service.get('shell.maxOutputChars')).toBe(10000);
-});
-it('loads settings from config file on startup', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        agent: {
-            model: 'custom-model',
-            reasoningEffort: 'high',
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(service.get('agent.model')).toBe('custom-model');
-    expect(service.get('agent.reasoningEffort')).toBe('high');
-});
-it('accepts xhigh reasoning effort for newer reasoning models', async () => {
-    const settingsDir = getTestSettingsDir();
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        agent: {
-            reasoningEffort: 'xhigh',
-            mentorReasoningEffort: 'xhigh',
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(service.get('agent.reasoningEffort')).toBe('xhigh');
-    expect(service.get('agent.mentorReasoningEffort')).toBe('xhigh');
-});
-it.sequential('persists changes to config file', async () => {
-    await withNonTestEnvironment(async () => {
-        const settingsDir = getTestSettingsDir();
-        const service = new SettingsService({
-            settingsDir,
-            disableLogging: true,
-        });
-        service.set('agent.model', 'gpt-4o');
-        // Read the config file directly
-        const configFile = path.join(settingsDir, 'settings.json');
-        const content = fs.readFileSync(configFile, 'utf-8');
-        const config = JSON.parse(content);
-        expect(config.agent.model).toBe('gpt-4o');
-    });
-});
-it('tracks setting sources correctly', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        shell: {
-            timeout: 60000,
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        env: {
-            agent: {
-                reasoningEffort: 'medium',
-            },
-        },
-        cli: {
-            agent: {
-                model: 'gpt-4o',
-            },
-        },
-    });
-    expect(service.getSource('agent.model')).toBe('cli');
-    expect(service.getSource('agent.reasoningEffort')).toBe('env');
-    expect(service.getSource('shell.timeout')).toBe('config');
-    expect(service.getSource('agent.maxTurns')).toBe('default');
-});
-it('deep merges partial settings from multiple sources', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-        cli: {
-            agent: {
-                model: 'cli-model',
-                // reasoningEffort not set in CLI
-            },
-        },
-        env: {
-            shell: {
-                timeout: 60000,
-                // maxOutputLines not set in env
-            },
-        },
-    });
-    // CLI should override for agent.model
-    expect(service.get('agent.model')).toBe('cli-model');
-    // Default for agent.reasoningEffort since not in CLI
-    expect(service.get('agent.reasoningEffort')).toBe('default');
-    // Env should override for shell.timeout
-    expect(service.get('shell.timeout')).toBe(60000);
-    // Default for shell.maxOutputLines since not in env
-    expect(service.get('shell.maxOutputLines')).toBe(1000);
-});
-it('getSource() returns default when setting not overridden', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(service.getSource('agent.model')).toBe('default');
-    expect(service.getSource('shell.timeout')).toBe('default');
-    expect(service.getSource('ui.historySize')).toBe('default');
-});
-it('validates enum values', async () => {
-    const settingsDir = getTestSettingsDir();
-    // Create a config file with invalid enum value
-    const configFile = path.join(settingsDir, 'settings.json');
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    fs.writeFileSync(configFile, JSON.stringify({
-        agent: {
-            reasoningEffort: 'invalid-effort',
-        },
-    }), 'utf-8');
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Should fall back to default for invalid enum
-    expect(service.get('agent.reasoningEffort')).toBe('default');
-});
-it('respects disableLogging flag', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    service.set('agent.model', 'gpt-4o');
-    // Should not throw
-    expect(true).toBe(true);
-});
-it.sequential('updates config file when new settings are added', async () => {
-    await withNonTestEnvironment(async () => {
-        const settingsDir = getTestSettingsDir();
-        const configFile = path.join(settingsDir, 'settings.json');
-        // Create a minimal config file without the 'provider' field
-        if (!fs.existsSync(settingsDir)) {
-            fs.mkdirSync(settingsDir, { recursive: true });
-        }
-        fs.writeFileSync(configFile, JSON.stringify({
-            agent: {
-                model: 'gpt-4o',
-                reasoningEffort: 'default',
-                maxTurns: 20,
-                retryAttempts: 2,
-                // Note: provider field is missing
-            },
-        }), 'utf-8');
-        // Initialize service - it should detect missing 'provider' and update the file
-        const service = new SettingsService({
-            settingsDir,
-            disableLogging: true,
-        });
-        // Verify service has the provider setting with default value
-        expect(service.get('agent.provider')).toBe('openai');
-        // Verify the file was updated with the new setting
-        const updatedContent = fs.readFileSync(configFile, 'utf-8');
-        const updatedConfig = JSON.parse(updatedContent);
-        expect(updatedConfig.agent.provider).toBe('openai');
-    });
-});
-it.sequential('does not update config file when no new settings are added', async () => {
-    const settingsDir = getTestSettingsDir();
-    const configFile = path.join(settingsDir, 'settings.json');
-    // Create a complete config file with all current settings
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    const originalConfig = {
-        agent: {
-            model: 'gpt-4o',
-            reasoningEffort: 'default',
-            maxTurns: 20,
-            retryAttempts: 2,
-            provider: 'openai',
-            openrouter: {},
-        },
-        shell: {
-            timeout: 120000,
-            maxOutputLines: 1000,
-            maxOutputChars: 10000,
-        },
-        ui: {
-            historySize: 1000,
-        },
-        logging: {
-            logLevel: 'info',
-            disableLogging: false,
-            debugLogging: false,
-            suppressConsoleOutput: true,
-        },
-        environment: {
-            nodeEnv: undefined,
-        },
-        app: {
-            shellPath: undefined,
-            mode: 'default',
-        },
-        tools: {
-            logFileOperations: true,
-        },
-        debug: {
-            debugBashTool: false,
-        },
-    };
-    fs.writeFileSync(configFile, JSON.stringify(originalConfig), 'utf-8');
-    // Spy on loggingService to ensure no update was triggered
-    let updateLogged = false;
-    const mockLogging = {
-        info: () => { },
-        error: () => { },
-        warn: () => { },
-        debug: (msg, meta) => {
-            if (msg.includes('Updated settings file') && meta?.settingsFile?.startsWith(settingsDir)) {
-                updateLogged = true;
-            }
-        },
-        security: () => { },
-        setLogLevel: () => { },
-        getLogLevel: () => 'info',
-        setCorrelationId: () => { },
-    };
-    // Initialize service - it should NOT update the file since all settings are present
-    new SettingsService({
-        settingsDir,
-        disableLogging: false,
-        loggingService: mockLogging,
-    });
-    expect(updateLogged).toBe(false);
-});
-it.sequential('does not update config file when format differs but content is same', async () => {
-    const settingsDir = getTestSettingsDir();
-    const configFile = path.join(settingsDir, 'settings.json');
-    // Create directory
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
-    }
-    // Write config with compact JSON (no formatting, different key order)
-    const compactConfig = {
-        agent: {
-            model: 'gpt-4o',
-            reasoningEffort: 'default',
-            maxTurns: 20,
-            retryAttempts: 2,
-            provider: 'openai',
-            openrouter: {},
-        },
-        shell: {
-            timeout: 120000,
-            maxOutputLines: 1000,
-            maxOutputChars: 10000,
-        },
-        ui: { historySize: 1000 },
-        logging: {
-            logLevel: 'info',
-            disableLogging: false,
-            debugLogging: false,
-            suppressConsoleOutput: true,
-        },
-        environment: { nodeEnv: undefined },
-        app: { shellPath: undefined, mode: 'default' },
-        tools: { logFileOperations: true },
-        debug: { debugBashTool: false },
-    };
-    fs.writeFileSync(configFile, JSON.stringify(compactConfig), 'utf-8');
-    // Spy on loggingService to ensure no update was triggered
-    let updateLogged = false;
-    const mockLogging = {
-        info: () => { },
-        error: () => { },
-        warn: () => { },
-        debug: (msg, meta) => {
-            if (msg.includes('Updated settings file') && meta?.settingsFile?.startsWith(settingsDir)) {
-                updateLogged = true;
-            }
-        },
-        security: () => { },
-        setLogLevel: () => { },
-        getLogLevel: () => 'info',
-        setCorrelationId: () => { },
-    };
-    // Initialize service - it should NOT update the file even though format differs
-    new SettingsService({
-        settingsDir,
-        disableLogging: false,
-        loggingService: mockLogging,
-    });
-    expect(updateLogged).toBe(false);
-});
-it('isSensitive() identifies sensitive settings', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Sensitive settings
-    expect(service.isSensitive('agent.openrouter.baseUrl')).toBe(true);
-    expect(service.isSensitive('agent.openrouter.referrer')).toBe(true);
-    expect(service.isSensitive('agent.openrouter.title')).toBe(true);
-    expect(service.isSensitive('app.shellPath')).toBe(true);
-    // Non-sensitive settings
-    expect(service.isSensitive('agent.model')).toBe(false);
-    expect(service.isSensitive('agent.openrouter.model')).toBe(false);
-    expect(service.isSensitive('shell.timeout')).toBe(false);
-    expect(service.isSensitive('logging.logLevel')).toBe(false);
-    expect(service.isSensitive('agent.openrouter.apiKey')).toBe(false);
-    expect(service.isSensitive('agent.openai.apiKey')).toBe(false);
-    expect(service.isSensitive('webSearch.tavily.apiKey')).toBe(false);
-    expect(service.isSensitive('webSearch.exa.apiKey')).toBe(false);
-});
-it('set() throws for sensitive settings', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(() => {
-        service.set('agent.openrouter.baseUrl', 'https://internal.api.com');
-    }).toThrow(/sensitive setting/);
-});
-it('reset() throws for sensitive settings', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    expect(() => {
-        service.reset('agent.openrouter.baseUrl');
-    }).toThrow(/sensitive setting/);
-});
-it.sequential('sensitive settings are never saved to config file', async () => {
-    await withNonTestEnvironment(async () => {
-        const settingsDir = getTestSettingsDir();
-        if (!fs.existsSync(settingsDir)) {
-            fs.mkdirSync(settingsDir, { recursive: true });
-        }
-        // Initialize with sensitive env values
-        new SettingsService({
-            settingsDir,
-            disableLogging: true,
-            env: {
-                agent: {
-                    openrouter: {
-                        apiKey: 'sk-secret-key',
-                        baseUrl: 'https://internal.api.com',
-                        referrer: 'internal-app',
-                        title: 'My Secret App',
-                        model: 'gpt-4', // NOT sensitive
-                    },
-                },
-                app: {
-                    shellPath: '/bin/bash',
-                },
-            },
-        });
-        // Read the saved config file
-        const configFile = path.join(settingsDir, 'settings.json');
-        const content = fs.readFileSync(configFile, 'utf-8');
-        const config = JSON.parse(content);
-        // Verify sensitive values are NOT in the file
-        expect(config.agent?.openrouter?.baseUrl).toBeFalsy();
-        expect(config.agent?.openrouter?.referrer).toBeFalsy();
-        expect(config.agent?.openrouter?.title).toBeFalsy();
-        expect(config.app?.shellPath).toBeFalsy();
-        // Verify non-sensitive openrouter values ARE saved
-        expect(config.agent?.openrouter?.model, 'model should be saved').toBe('gpt-4');
-        expect(config.agent?.openrouter?.apiKey, 'apiKey should be saved').toBe('sk-secret-key');
-    });
-});
-it.sequential('sensitive settings loaded from env are accessible at runtime', async () => {
-    await withNonTestEnvironment(async () => {
-        const settingsDir = getTestSettingsDir();
-        const service = new SettingsService({
-            settingsDir,
-            disableLogging: true,
-            env: {
-                agent: {
-                    openrouter: {
-                        apiKey: 'sk-secret-key',
-                        baseUrl: 'https://internal.api.com',
-                    },
-                },
-                app: {
-                    shellPath: '/bin/bash',
-                },
-            },
-        });
-        // Verify sensitive values ARE accessible at runtime
-        expect(service.get('agent.openrouter.apiKey')).toBe('sk-secret-key');
-        expect(service.get('agent.openrouter.baseUrl')).toBe('https://internal.api.com');
-        expect(service.get('app.shellPath')).toBe('/bin/bash');
-        // But they should not be in the saved file
-        const configFile = path.join(settingsDir, 'settings.json');
-        const content = fs.readFileSync(configFile, 'utf-8');
-        const config = JSON.parse(content);
-        expect(config.agent?.openrouter?.baseUrl).toBeFalsy();
-        expect(config.app?.shellPath).toBeFalsy();
-        expect(config.agent?.openrouter?.apiKey).toBe('sk-secret-key');
-    });
-});
-it('set() enables target app mode and disables sibling modes', async () => {
-    const settingsDir = getTestSettingsDir();
-    const service = new SettingsService({
-        settingsDir,
-        disableLogging: true,
-    });
-    // Enable orchestrator mode initially
-    service.set('app.orchestratorMode', true);
-    expect(service.get('app.orchestratorMode')).toBe(true);
-    expect(service.get('app.liteMode')).toBe(false);
-    expect(service.get('app.planMode')).toBe(false);
-    expect(service.get('app.mentorMode')).toBe(false);
-    // Setting liteMode to true should disable orchestratorMode
-    service.set('app.liteMode', true);
-    expect(service.get('app.liteMode')).toBe(true);
-    expect(service.get('app.orchestratorMode')).toBe(false);
-    expect(service.get('app.planMode')).toBe(false);
-    expect(service.get('app.mentorMode')).toBe(false);
-    // Setting planMode to true should disable liteMode
-    service.set('app.planMode', true);
-    expect(service.get('app.planMode')).toBe(true);
-    expect(service.get('app.liteMode')).toBe(false);
-    expect(service.get('app.orchestratorMode')).toBe(false);
-    expect(service.get('app.mentorMode')).toBe(false);
-});
-//# sourceMappingURL=settings-service.test.js.map