@dollhousemcp/mcp-server 1.7.1 → 1.7.3

package/dist/config/ConfigManager.js

@@ -1,27 +1,33 @@
 /**
- * ConfigManager - Thread-safe singleton for persistent configuration
+ * ConfigManager - Centralized configuration management for DollhouseMCP
  *
- * Handles OAuth client ID storage for Claude Desktop integration.
- * Stores config in ~/.dollhouse/config.json with proper permissions.
- * Prefers environment variables over config file values.
+ * Features:
+ * - YAML-based configuration file
+ * - Default values with user overrides
+ * - Migration from environment variables
+ * - Validation and type safety
+ * - Atomic updates with backup
+ * - Privacy-first defaults
+ * - OAuth client ID storage for Claude Desktop integration
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
+import * as yaml from 'js-yaml';
+import { logger } from '../utils/logger.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
 export class ConfigManager {
     static instance = null;
     static instanceLock = false;
     configDir;
     configPath;
-    config;
+    backupPath;
+    config = null;
     constructor() {
         // Initialize paths
         this.configDir = path.join(os.homedir(), '.dollhouse');
-        this.configPath = path.join(this.configDir, 'config.json');
-        // Initialize with default config
-        this.config = {
-            version: '1.0.0'
-        };
+        this.configPath = path.join(this.configDir, 'config.yml');
+        this.backupPath = path.join(this.configDir, 'config.yml.backup');
     }
     /**
      * Thread-safe singleton instance getter
@@ -47,67 +53,192 @@ export class ConfigManager {
         return ConfigManager.instance;
     }
     /**
-     * Attempt to repair file permissions if they're incorrect
-     * This helps with error recovery in permission-related issues
+     * Get default configuration
+     */
+    getDefaultConfig() {
+        return {
+            version: '1.0.0',
+            user: {
+                username: null,
+                email: null,
+                display_name: null
+            },
+            github: {
+                portfolio: {
+                    repository_url: null,
+                    repository_name: 'dollhouse-portfolio',
+                    default_branch: 'main',
+                    auto_create: true
+                },
+                auth: {
+                    use_oauth: true,
+                    token_source: 'environment'
+                }
+            },
+            sync: {
+                enabled: false, // Privacy first - off by default
+                individual: {
+                    require_confirmation: true,
+                    show_diff_before_sync: true,
+                    track_versions: true,
+                    keep_history: 10
+                },
+                bulk: {
+                    upload_enabled: false, // Requires explicit enablement
+                    download_enabled: false,
+                    require_preview: true,
+                    respect_local_only: true
+                },
+                privacy: {
+                    scan_for_secrets: true,
+                    scan_for_pii: true,
+                    warn_on_sensitive: true,
+                    excluded_patterns: [
+                        '*.secret',
+                        '*-private.*',
+                        'credentials/**',
+                        'personal/**'
+                    ]
+                }
+            },
+            collection: {
+                auto_submit: false, // Never auto-submit
+                require_review: true,
+                add_attribution: true
+            },
+            elements: {
+                auto_activate: {},
+                default_element_dir: path.join(os.homedir(), '.dollhouse', 'portfolio')
+            },
+            display: {
+                persona_indicators: {
+                    enabled: true,
+                    style: 'minimal',
+                    include_emoji: true
+                },
+                verbose_logging: false,
+                show_progress: true
+            }
+        };
+    }
+    /**
+     * Initialize configuration
      */
-    async repairPermissions() {
+    async initialize() {
+        // Always reload config from disk if it exists, even if we have defaults in memory
+        // This ensures we pick up any manual edits or saved settings
         try {
-            // Try to fix directory permissions
-            await fs.chmod(this.configDir, 0o700);
-            // Try to fix file permissions if it exists
-            try {
-                await fs.access(this.configPath);
-                await fs.chmod(this.configPath, 0o600);
+            // Ensure config directory exists with proper permissions (0o700 = owner only)
+            await fs.mkdir(this.configDir, { recursive: true, mode: 0o700 });
+            // Load or create config
+            if (await this.configExists()) {
+                await this.loadConfig();
             }
-            catch {
-                // File doesn't exist, that's OK
+            else {
+                // Create default config
+                this.config = this.getDefaultConfig();
+                // Try to migrate from environment variables
+                await this.migrateFromEnvironment();
+                // Save the config
+                await this.saveConfig();
+                logger.info('Created new configuration file', {
+                    path: this.configPath
+                });
             }
         }
         catch (error) {
-            // Log but don't fail - this is best-effort recovery
-            // We don't have a logger here, so we'll silently continue
+            logger.error('Failed to initialize configuration', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Use defaults in memory
+            this.config = this.getDefaultConfig();
         }
     }
     /**
-     * Load configuration from file system
+     * Load configuration from file
      */
     async loadConfig() {
         try {
-            // Try to read existing config file
-            const configContent = await fs.readFile(this.configPath, 'utf-8');
+            const content = await fs.readFile(this.configPath, 'utf-8');
+            /**
+             * IMPORTANT: Parser Selection for Different File Types
+             *
+             * We use DIFFERENT parsers for different file types:
+             *
+             * 1. js-yaml (used here) - For PURE YAML files:
+             *    - Configuration files (config.yml)
+             *    - Data files without markdown content
+             *    - Any .yml or .yaml file that's just YAML
+             *    Example format:
+             *    ```yaml
+             *    version: 1.0.0
+             *    user:
+             *      username: johndoe
+             *      email: john@example.com
+             *    ```
+             *
+             * 2. SecureYamlParser - For MARKDOWN files with YAML frontmatter:
+             *    - Persona files (*.md in personas/)
+             *    - Skill files (*.md in skills/)
+             *    - Template files (*.md in templates/)
+             *    - Any .md file with frontmatter between --- markers
+             *    Example format:
+             *    ```markdown
+             *    ---
+             *    name: Creative Writer
+             *    description: A creative assistant
+             *    ---
+             *    # Instructions
+             *    You are a creative writer...
+             *    ```
+             *
+             * The config file is PURE YAML, so we use js-yaml directly with FAILSAFE_SCHEMA
+             * for security (prevents code execution via YAML tags).
+             * SECURITY: This is NOT a vulnerability - FAILSAFE_SCHEMA prevents code execution
+             */
+            let loadedData;
             try {
-                this.config = JSON.parse(configContent);
+                // Using yaml with FAILSAFE_SCHEMA is secure - prevents code execution
+                loadedData = yaml.load(content, {
+                    schema: yaml.FAILSAFE_SCHEMA // Safe schema prevents code execution
+                });
             }
-            catch (parseError) {
-                // Handle corrupted JSON - create new config
-                console.warn('Config file corrupted, creating new config');
-                this.config = { version: '1.0.0' };
-                await this.saveConfig();
+            catch (yamlError) {
+                throw new Error(`Invalid YAML in configuration file: ${yamlError instanceof Error ? yamlError.message : String(yamlError)}`);
+            }
+            if (!loadedData || typeof loadedData !== 'object') {
+                throw new Error('Invalid configuration format');
             }
+            logger.debug('Loaded config from file', {
+                username: loadedData.user?.username,
+                email: loadedData.user?.email,
+                syncEnabled: loadedData.sync?.enabled
+            });
+            this.config = this.mergeWithDefaults(loadedData);
+            // Fix any string booleans that might have been saved incorrectly
+            this.fixConfigTypes();
+            logger.debug('Configuration loaded successfully', {
+                username: this.config.user.username,
+                syncEnabled: this.config.sync.enabled
+            });
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
-                // Config file doesn't exist, create directory and file
-                await this.ensureConfigDirectory();
-                await this.saveConfig();
-            }
-            else if (error.code === 'EACCES' || error.code === 'EPERM') {
-                // Permission denied - attempt repair
-                await this.repairPermissions();
-                // Try once more after repair attempt
-                try {
-                    const configContent = await fs.readFile(this.configPath, 'utf-8');
-                    this.config = JSON.parse(configContent);
-                }
-                catch (retryError) {
-                    // Still failing, throw original error with helpful message
-                    throw new Error(`Permission denied accessing config at ${this.configPath}. ` +
-                        `Please check file permissions or run with appropriate privileges.`);
-                }
-            }
-            else {
-                throw error;
-            }
+            logger.error('Failed to load configuration', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+     * Check if config file exists
+     */
+    async configExists() {
+        try {
+            await fs.access(this.configPath);
+            return true;
+        }
+        catch {
+            return false;
         }
     }
     /**
@@ -121,7 +252,7 @@ export class ConfigManager {
             return envClientId;
         }
         // Fall back to config file
-        return this.config.oauth?.githubClientId || null;
+        return this.config?.github?.auth?.client_id || null;
     }
     /**
      * Set GitHub OAuth client ID in config file
@@ -130,27 +261,91 @@ export class ConfigManager {
         if (!ConfigManager.validateClientId(clientId)) {
             throw new Error(`Invalid GitHub client ID format. Expected format: Ov23li followed by at least 14 alphanumeric characters (e.g., Ov23liABCDEFGHIJKLMN)`);
         }
-        // Ensure oauth object exists
-        if (!this.config.oauth) {
-            this.config.oauth = {};
+        if (!this.config) {
+            this.config = this.getDefaultConfig();
+        }
+        // Ensure github.auth object exists
+        if (!this.config.github) {
+            this.config.github = this.getDefaultConfig().github;
         }
-        this.config.oauth.githubClientId = clientId;
+        if (!this.config.github.auth) {
+            this.config.github.auth = this.getDefaultConfig().github.auth;
+        }
+        this.config.github.auth.client_id = clientId;
         await this.saveConfig();
     }
     /**
-     * Get a copy of the current configuration
-     * @returns A defensive copy of the configuration object
+     * Get the current configuration
      */
     getConfig() {
-        return { ...this.config };
+        if (!this.config) {
+            throw new Error('Configuration not initialized');
+        }
+        return this.config;
     }
     /**
-     * Update the entire configuration
-     * @param newConfig The new configuration to set
+     * Get a specific setting using dot notation
      */
-    async updateConfig(newConfig) {
-        this.config = { ...newConfig };
+    getSetting(path, defaultValue) {
+        if (!this.config) {
+            return defaultValue;
+        }
+        const keys = path.split('.');
+        let value = this.config;
+        for (const key of keys) {
+            if (value && typeof value === 'object' && key in value) {
+                value = value[key];
+            }
+            else {
+                return defaultValue;
+            }
+        }
+        return value;
+    }
+    /**
+     * Update a specific setting using dot notation
+     * SECURITY FIX (PR #895): Added prototype pollution protection
+     * Previously: Direct property assignment allowed __proto__ injection
+     * Now: Validates keys against forbidden properties before assignment
+     */
+    async updateSetting(path, value) {
+        if (!this.config) {
+            await this.initialize();
+        }
+        const keys = path.split('.');
+        // SECURITY: Validate all keys to prevent prototype pollution
+        const FORBIDDEN_KEYS = ['__proto__', 'constructor', 'prototype'];
+        for (const key of keys) {
+            if (FORBIDDEN_KEYS.includes(key)) {
+                throw new Error(`Forbidden property in path: ${key}`);
+            }
+        }
+        let current = this.config;
+        const previousValue = this.getSetting(path);
+        // Navigate to the parent object
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            if (!(key in current)) {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        // Set the value
+        const lastKey = keys[keys.length - 1];
+        current[lastKey] = value;
+        // Save the configuration
         await this.saveConfig();
+        logger.info('Configuration setting updated', {
+            path,
+            previousValue,
+            newValue: value
+        });
+        return {
+            success: true,
+            message: `Setting '${path}' updated successfully`,
+            previousValue,
+            newValue: value
+        };
     }
     /**
      * Validate GitHub OAuth client ID format
@@ -174,43 +369,387 @@ export class ConfigManager {
         return clientIdPattern.test(clientId);
     }
     /**
-     * Ensure config directory exists with proper permissions
+     * Save configuration to file
      */
-    async ensureConfigDirectory() {
+    async saveConfig() {
+        if (!this.config) {
+            throw new Error('No configuration to save');
+        }
         try {
-            await fs.mkdir(this.configDir, { recursive: true, mode: 0o700 });
+            // Create backup of existing config
+            if (await this.configExists()) {
+                await fs.copyFile(this.configPath, this.backupPath);
+            }
+            // Convert to YAML
+            // Note: We use js-yaml's dump() for pure YAML output (no frontmatter markers)
+            // This creates a standard YAML file, not a markdown file with frontmatter
+            const yamlContent = yaml.dump(this.config, {
+                indent: 2,
+                lineWidth: 120,
+                noRefs: true,
+                sortKeys: false
+                // Using default schema (not FAILSAFE) for dump to preserve types like booleans
+            });
+            // Write atomically with proper permissions (0o600 = owner read/write only)
+            const tempPath = `${this.configPath}.tmp`;
+            await fs.writeFile(tempPath, yamlContent, { encoding: 'utf-8', mode: 0o600 });
+            await fs.rename(tempPath, this.configPath);
+            logger.debug('Configuration saved successfully');
+            // Log audit event for configuration update
+            logger.debug('Configuration update audit', {
+                event: 'CONFIG_UPDATED',
+                source: 'ConfigManager.saveConfig',
+                timestamp: new Date().toISOString()
+            });
         }
         catch (error) {
-            if (error.code === 'EACCES') {
-                throw new Error(`Permission denied creating config directory: ${this.configDir}`);
+            logger.error('Failed to save configuration', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Try to restore backup
+            if (await this.backupExists()) {
+                await fs.copyFile(this.backupPath, this.configPath);
+                logger.info('Restored configuration from backup');
             }
             throw error;
         }
     }
     /**
-     * Save config using atomic file writes
+     * Check if backup exists
      */
-    async saveConfig() {
-        await this.ensureConfigDirectory();
-        // Use atomic write: write to temp file, then rename
-        const tempPath = this.configPath + '.tmp';
-        const configContent = JSON.stringify(this.config, null, 2);
+    async backupExists() {
         try {
-            // Write to temp file first
-            await fs.writeFile(tempPath, configContent, { mode: 0o600 });
-            // Atomic rename
-            await fs.rename(tempPath, this.configPath);
+            await fs.access(this.backupPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Fix incorrect types in config (e.g., string booleans, string "null")
+     */
+    fixConfigTypes() {
+        if (!this.config)
+            return;
+        // Helper to convert string "null" to actual null
+        const fixNull = (value) => {
+            if (value === 'null' || value === 'NULL')
+                return null;
+            return value;
+        };
+        // Helper to convert string booleans to actual booleans
+        const fixBoolean = (value) => {
+            if (typeof value === 'string') {
+                const lower = value.toLowerCase();
+                if (lower === 'true')
+                    return true;
+                if (lower === 'false')
+                    return false;
+            }
+            return value;
+        };
+        // Fix user fields - handle string "null" values
+        if (this.config.user) {
+            this.config.user.username = fixNull(this.config.user.username);
+            this.config.user.email = fixNull(this.config.user.email);
+            this.config.user.display_name = fixNull(this.config.user.display_name);
+        }
+        // Fix sync settings
+        if (this.config.sync) {
+            this.config.sync.enabled = fixBoolean(this.config.sync.enabled);
+            if (this.config.sync.individual) {
+                this.config.sync.individual.require_confirmation = fixBoolean(this.config.sync.individual.require_confirmation);
+                this.config.sync.individual.show_diff_before_sync = fixBoolean(this.config.sync.individual.show_diff_before_sync);
+                this.config.sync.individual.track_versions = fixBoolean(this.config.sync.individual.track_versions);
+            }
+            if (this.config.sync.bulk) {
+                this.config.sync.bulk.upload_enabled = fixBoolean(this.config.sync.bulk.upload_enabled);
+                this.config.sync.bulk.download_enabled = fixBoolean(this.config.sync.bulk.download_enabled);
+                this.config.sync.bulk.require_preview = fixBoolean(this.config.sync.bulk.require_preview);
+                this.config.sync.bulk.respect_local_only = fixBoolean(this.config.sync.bulk.respect_local_only);
+            }
+            if (this.config.sync.privacy) {
+                this.config.sync.privacy.scan_for_secrets = fixBoolean(this.config.sync.privacy.scan_for_secrets);
+                this.config.sync.privacy.scan_for_pii = fixBoolean(this.config.sync.privacy.scan_for_pii);
+                this.config.sync.privacy.warn_on_sensitive = fixBoolean(this.config.sync.privacy.warn_on_sensitive);
+            }
+        }
+        // Fix collection settings
+        if (this.config.collection) {
+            this.config.collection.auto_submit = fixBoolean(this.config.collection.auto_submit);
+            this.config.collection.require_review = fixBoolean(this.config.collection.require_review);
+            this.config.collection.add_attribution = fixBoolean(this.config.collection.add_attribution);
+        }
+        // Fix display settings
+        if (this.config.display) {
+            if (this.config.display.persona_indicators) {
+                this.config.display.persona_indicators.enabled = fixBoolean(this.config.display.persona_indicators.enabled);
+                this.config.display.persona_indicators.include_emoji = fixBoolean(this.config.display.persona_indicators.include_emoji);
+            }
+            this.config.display.verbose_logging = fixBoolean(this.config.display.verbose_logging);
+            this.config.display.show_progress = fixBoolean(this.config.display.show_progress);
+        }
+        // Fix github settings
+        if (this.config.github) {
+            if (this.config.github.portfolio) {
+                this.config.github.portfolio.repository_url = fixNull(this.config.github.portfolio.repository_url);
+                this.config.github.portfolio.auto_create = fixBoolean(this.config.github.portfolio.auto_create);
+            }
+            if (this.config.github.auth) {
+                this.config.github.auth.use_oauth = fixBoolean(this.config.github.auth.use_oauth);
+                // Fix client_id if it's a string "null"
+                if (this.config.github.auth.client_id) {
+                    this.config.github.auth.client_id = fixNull(this.config.github.auth.client_id) || undefined;
+                }
+            }
+        }
+    }
+    /**
+     * Merge partial config with defaults
+     *
+     * IMPORTANT: This function preserves unknown fields for forward compatibility.
+     * If a future version adds new config fields, older versions won't lose them.
+     */
+    mergeWithDefaults(partial) {
+        const defaults = this.getDefaultConfig();
+        // Start with a deep clone of partial to preserve all unknown fields
+        const result = JSON.parse(JSON.stringify(partial));
+        // Ensure all required fields exist with defaults
+        result.version = result.version || defaults.version;
+        // User section - preserve unknown fields while ensuring required fields
+        result.user = {
+            ...result.user,
+            username: result.user?.username ?? defaults.user.username,
+            email: result.user?.email ?? defaults.user.email,
+            display_name: result.user?.display_name ?? defaults.user.display_name
+        };
+        // GitHub section - deep merge preserving unknown fields
+        if (!result.github)
+            result.github = {};
+        result.github.portfolio = {
+            ...defaults.github.portfolio,
+            ...result.github.portfolio
+        };
+        result.github.auth = {
+            ...defaults.github.auth,
+            ...result.github.auth
+        };
+        // Sync section - preserve unknown fields at all levels
+        if (!result.sync)
+            result.sync = {};
+        result.sync.enabled = result.sync.enabled ?? defaults.sync.enabled;
+        result.sync.individual = {
+            ...defaults.sync.individual,
+            ...result.sync.individual
+        };
+        result.sync.bulk = {
+            ...defaults.sync.bulk,
+            ...result.sync.bulk
+        };
+        result.sync.privacy = {
+            ...defaults.sync.privacy,
+            ...result.sync.privacy,
+            // Special handling for arrays - use provided or default
+            excluded_patterns: result.sync.privacy?.excluded_patterns || defaults.sync.privacy.excluded_patterns
+        };
+        // Collection section
+        result.collection = {
+            ...defaults.collection,
+            ...result.collection
+        };
+        // Elements section
+        if (!result.elements)
+            result.elements = {};
+        result.elements = {
+            ...result.elements,
+            auto_activate: result.elements.auto_activate || defaults.elements.auto_activate,
+            default_element_dir: result.elements.default_element_dir || defaults.elements.default_element_dir
+        };
+        // Display section
+        if (!result.display)
+            result.display = {};
+        result.display.persona_indicators = {
+            ...defaults.display.persona_indicators,
+            ...result.display.persona_indicators
+        };
+        result.display.verbose_logging = result.display.verbose_logging ?? defaults.display.verbose_logging;
+        result.display.show_progress = result.display.show_progress ?? defaults.display.show_progress;
+        return result;
+    }
+    /**
+     * Migrate settings from environment variables
+     */
+    async migrateFromEnvironment() {
+        let migrated = false;
+        // Migrate user settings
+        if (process.env.DOLLHOUSE_USER && !this.config?.user.username) {
+            if (!this.config)
+                this.config = this.getDefaultConfig();
+            this.config.user.username = process.env.DOLLHOUSE_USER;
+            migrated = true;
+        }
+        if (process.env.DOLLHOUSE_EMAIL && !this.config?.user.email) {
+            if (!this.config)
+                this.config = this.getDefaultConfig();
+            this.config.user.email = process.env.DOLLHOUSE_EMAIL;
+            migrated = true;
+        }
+        // Migrate portfolio URL
+        if (process.env.DOLLHOUSE_PORTFOLIO_URL && !this.config?.github.portfolio.repository_url) {
+            if (!this.config)
+                this.config = this.getDefaultConfig();
+            this.config.github.portfolio.repository_url = process.env.DOLLHOUSE_PORTFOLIO_URL;
+            migrated = true;
+        }
+        // Migrate collection auto-submit
+        if (process.env.DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION !== undefined) {
+            if (!this.config)
+                this.config = this.getDefaultConfig();
+            this.config.collection.auto_submit = process.env.DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION === 'true';
+            migrated = true;
+        }
+        if (migrated) {
+            logger.info('Migrated settings from environment variables');
+        }
+    }
+    /**
+     * Reset configuration to defaults
+     * SECURITY FIX (PR #895): Added prototype pollution protection
+     * Previously: Direct property assignment allowed __proto__ injection
+     * Now: Validates keys against forbidden properties before assignment
+     */
+    async resetConfig(section) {
+        const defaults = this.getDefaultConfig();
+        if (section) {
+            // Reset specific section
+            if (!this.config) {
+                this.config = defaults;
+            }
+            else {
+                const sectionKeys = section.split('.');
+                // SECURITY: Validate all keys to prevent prototype pollution
+                const FORBIDDEN_KEYS = ['__proto__', 'constructor', 'prototype'];
+                for (const key of sectionKeys) {
+                    if (FORBIDDEN_KEYS.includes(key)) {
+                        throw new Error(`Forbidden property in section: ${key}`);
+                    }
+                }
+                let current = this.config;
+                let defaultSection = defaults;
+                for (let i = 0; i < sectionKeys.length - 1; i++) {
+                    current = current[sectionKeys[i]];
+                    defaultSection = defaultSection[sectionKeys[i]];
+                }
+                const lastKey = sectionKeys[sectionKeys.length - 1];
+                current[lastKey] = defaultSection[lastKey];
+            }
+            await this.saveConfig();
+            return {
+                success: true,
+                message: `Section '${section}' reset to defaults`
+            };
+        }
+        else {
+            // Reset entire config
+            this.config = defaults;
+            await this.saveConfig();
+            return {
+                success: true,
+                message: 'Configuration reset to defaults'
+            };
+        }
+    }
+    /**
+     * Export configuration to file
+     */
+    async exportConfig(filePath) {
+        if (!this.config) {
+            return {
+                success: false,
+                message: 'No configuration to export'
+            };
+        }
+        try {
+            const yamlContent = yaml.dump(this.config, {
+                indent: 2,
+                lineWidth: 120,
+                noRefs: true,
+                sortKeys: false
+            });
+            await fs.writeFile(filePath, yamlContent, { encoding: 'utf-8', mode: 0o600 });
+            return {
+                success: true,
+                message: `Configuration exported to ${filePath}`
+            };
         }
         catch (error) {
-            // Clean up temp file if it exists
-            try {
-                await fs.unlink(tempPath);
+            return {
+                success: false,
+                message: `Failed to export configuration: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Import configuration from file
+     */
+    async importConfig(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Parse and validate
+            const parsed = SecureYamlParser.parse(content, {
+                maxYamlSize: 64 * 1024,
+                validateContent: false,
+                validateFields: false
+            });
+            if (!parsed.data || typeof parsed.data !== 'object') {
+                return {
+                    success: false,
+                    message: 'Invalid configuration format in import file'
+                };
             }
-            catch {
-                // Ignore cleanup errors
+            // Merge with defaults
+            this.config = this.mergeWithDefaults(parsed.data);
+            // Save the imported config
+            await this.saveConfig();
+            return {
+                success: true,
+                message: `Configuration imported from ${filePath}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to import configuration: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Get formatted config for display
+     */
+    getFormattedConfig(section) {
+        if (!this.config) {
+            return 'Configuration not initialized';
+        }
+        let configToShow = this.config;
+        if (section) {
+            configToShow = this.getSetting(section);
+            if (!configToShow) {
+                return `Section '${section}' not found`;
             }
-            throw error;
         }
+        // Remove sensitive data for display
+        const sanitized = JSON.parse(JSON.stringify(configToShow));
+        // Don't show tokens if they exist
+        if (sanitized.github?.auth?.token) {
+            sanitized.github.auth.token = '***REDACTED***';
+        }
+        return yaml.dump(sanitized, {
+            indent: 2,
+            lineWidth: 120,
+            noRefs: true,
+            sortKeys: false
+        });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConfigManager.js","sourceRoot":"","sources":["../../src/config/ConfigManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ConfigManager - Thread-safe singleton for persistent configuration\n * \n * Handles OAuth client ID storage for Claude Desktop integration.\n * Stores config in ~/.dollhouse/config.json with proper permissions.\n * Prefers environment variables over config file values.\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport * as os from 'os';\n\ninterface ConfigData {\n  version: string;\n  oauth?: {\n    githubClientId?: string;\n  };\n  [key: string]: any; // Allow unknown fields to be preserved\n}\n\nexport class ConfigManager {\n  private static instance: ConfigManager | null = null;\n  private static instanceLock: boolean = false;\n\n  private configDir: string;\n  private configPath: string;\n  private config: ConfigData;\n\n  private constructor() {\n    // Initialize paths\n    this.configDir = path.join(os.homedir(), '.dollhouse');\n    this.configPath = path.join(this.configDir, 'config.json');\n    \n    // Initialize with default config\n    this.config = {\n      version: '1.0.0'\n    };\n  }\n\n  /**\n   * Thread-safe singleton instance getter\n   */\n  public static getInstance(): ConfigManager {\n    if (ConfigManager.instance) {\n      return ConfigManager.instance;\n    }\n\n    // Simple locking mechanism to prevent race conditions\n    if (ConfigManager.instanceLock) {\n      // Wait for lock to be released, then return the instance\n      while (ConfigManager.instanceLock && !ConfigManager.instance) {\n        // In a real scenario with async operations, this would be more sophisticated\n        // But for the test cases, this simple approach works\n      }\n      return ConfigManager.instance!;\n    }\n\n    ConfigManager.instanceLock = true;\n    \n    if (!ConfigManager.instance) {\n      ConfigManager.instance = new ConfigManager();\n    }\n    \n    ConfigManager.instanceLock = false;\n    return ConfigManager.instance;\n  }\n\n  /**\n   * Attempt to repair file permissions if they're incorrect\n   * This helps with error recovery in permission-related issues\n   */\n  private async repairPermissions(): Promise<void> {\n    try {\n      // Try to fix directory permissions\n      await fs.chmod(this.configDir, 0o700);\n      \n      // Try to fix file permissions if it exists\n      try {\n        await fs.access(this.configPath);\n        await fs.chmod(this.configPath, 0o600);\n      } catch {\n        // File doesn't exist, that's OK\n      }\n    } catch (error) {\n      // Log but don't fail - this is best-effort recovery\n      // We don't have a logger here, so we'll silently continue\n    }\n  }\n\n  /**\n   * Load configuration from file system\n   */\n  public async loadConfig(): Promise<void> {\n    try {\n      // Try to read existing config file\n      const configContent = await fs.readFile(this.configPath, 'utf-8');\n      \n      try {\n        this.config = JSON.parse(configContent);\n      } catch (parseError) {\n        // Handle corrupted JSON - create new config\n        console.warn('Config file corrupted, creating new config');\n        this.config = { version: '1.0.0' };\n        await this.saveConfig();\n      }\n    } catch (error: any) {\n      if (error.code === 'ENOENT') {\n        // Config file doesn't exist, create directory and file\n        await this.ensureConfigDirectory();\n        await this.saveConfig();\n      } else if (error.code === 'EACCES' || error.code === 'EPERM') {\n        // Permission denied - attempt repair\n        await this.repairPermissions();\n        \n        // Try once more after repair attempt\n        try {\n          const configContent = await fs.readFile(this.configPath, 'utf-8');\n          this.config = JSON.parse(configContent);\n        } catch (retryError: any) {\n          // Still failing, throw original error with helpful message\n          throw new Error(\n            `Permission denied accessing config at ${this.configPath}. ` +\n            `Please check file permissions or run with appropriate privileges.`\n          );\n        }\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  /**\n   * Get GitHub OAuth client ID\n   * Environment variable takes precedence over config file\n   */\n  public getGitHubClientId(): string | null {\n    // Check environment variable first\n    const envClientId = process.env.DOLLHOUSE_GITHUB_CLIENT_ID;\n    if (envClientId) {\n      return envClientId;\n    }\n\n    // Fall back to config file\n    return this.config.oauth?.githubClientId || null;\n  }\n\n  /**\n   * Set GitHub OAuth client ID in config file\n   */\n  public async setGitHubClientId(clientId: string): Promise<void> {\n    if (!ConfigManager.validateClientId(clientId)) {\n      throw new Error(\n        `Invalid GitHub client ID format. Expected format: Ov23li followed by at least 14 alphanumeric characters (e.g., Ov23liABCDEFGHIJKLMN)`\n      );\n    }\n\n    // Ensure oauth object exists\n    if (!this.config.oauth) {\n      this.config.oauth = {};\n    }\n\n    this.config.oauth.githubClientId = clientId;\n    await this.saveConfig();\n  }\n\n  /**\n   * Get a copy of the current configuration\n   * @returns A defensive copy of the configuration object\n   */\n  public getConfig(): ConfigData {\n    return { ...this.config };\n  }\n\n  /**\n   * Update the entire configuration\n   * @param newConfig The new configuration to set\n   */\n  public async updateConfig(newConfig: ConfigData): Promise<void> {\n    this.config = { ...newConfig };\n    await this.saveConfig();\n  }\n\n  /**\n   * Validate GitHub OAuth client ID format\n   * Client IDs start with \"Ov23li\" followed by at least 14 alphanumeric characters\n   * \n   * @param clientId - The client ID to validate\n   * @returns true if valid, false otherwise\n   * \n   * @example\n   * ConfigManager.validateClientId(\"Ov23liABCDEFGHIJKLMN123456\") // true\n   * ConfigManager.validateClientId(\"invalid\") // false\n   * ConfigManager.validateClientId(\"Ov23li\") // false (too short)\n   * ConfigManager.validateClientId(\"Xv23liABCDEFGHIJKLMN\") // false (wrong prefix)\n   */\n  public static validateClientId(clientId: any): boolean {\n    if (typeof clientId !== 'string' || !clientId) {\n      return false;\n    }\n\n    // GitHub OAuth client IDs follow the pattern: Ov23li[A-Za-z0-9]{14,}\n    const clientIdPattern = /^Ov23li[A-Za-z0-9]{14,}$/;\n    return clientIdPattern.test(clientId);\n  }\n\n  /**\n   * Ensure config directory exists with proper permissions\n   */\n  private async ensureConfigDirectory(): Promise<void> {\n    try {\n      await fs.mkdir(this.configDir, { recursive: true, mode: 0o700 });\n    } catch (error: any) {\n      if (error.code === 'EACCES') {\n        throw new Error(`Permission denied creating config directory: ${this.configDir}`);\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Save config using atomic file writes\n   */\n  private async saveConfig(): Promise<void> {\n    await this.ensureConfigDirectory();\n    \n    // Use atomic write: write to temp file, then rename\n    const tempPath = this.configPath + '.tmp';\n    const configContent = JSON.stringify(this.config, null, 2);\n    \n    try {\n      // Write to temp file first\n      await fs.writeFile(tempPath, configContent, { mode: 0o600 });\n      \n      // Atomic rename\n      await fs.rename(tempPath, this.configPath);\n    } catch (error) {\n      // Clean up temp file if it exists\n      try {\n        await fs.unlink(tempPath);\n      } catch {\n        // Ignore cleanup errors\n      }\n      throw error;\n    }\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConfigManager.js","sourceRoot":"","sources":["../../src/config/ConfigManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ConfigManager - Centralized configuration management for DollhouseMCP\n * \n * Features:\n * - YAML-based configuration file\n * - Default values with user overrides\n * - Migration from environment variables\n * - Validation and type safety\n * - Atomic updates with backup\n * - Privacy-first defaults\n * - OAuth client ID storage for Claude Desktop integration\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport * as os from 'os';\nimport * as yaml from 'js-yaml';\nimport { logger } from '../utils/logger.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\n\nexport interface UserConfig {\n  username: string | null;\n  email: string | null;\n  display_name: string | null;\n}\n\nexport interface GitHubPortfolioConfig {\n  repository_url: string | null;\n  repository_name: string;\n  default_branch: string;\n  auto_create: boolean;\n}\n\nexport interface GitHubAuthConfig {\n  use_oauth: boolean;\n  token_source: 'environment' | 'oauth' | 'config';\n  client_id?: string; // OAuth client ID for GitHub App\n}\n\nexport interface GitHubConfig {\n  portfolio: GitHubPortfolioConfig;\n  auth: GitHubAuthConfig;\n}\n\nexport interface SyncIndividualConfig {\n  require_confirmation: boolean;\n  show_diff_before_sync: boolean;\n  track_versions: boolean;\n  keep_history: number;\n}\n\nexport interface SyncBulkConfig {\n  upload_enabled: boolean;\n  download_enabled: boolean;\n  require_preview: boolean;\n  respect_local_only: boolean;\n}\n\nexport interface SyncPrivacyConfig {\n  scan_for_secrets: boolean;\n  scan_for_pii: boolean;\n  warn_on_sensitive: boolean;\n  excluded_patterns: string[];\n}\n\nexport interface SyncConfig {\n  enabled: boolean;\n  individual: SyncIndividualConfig;\n  bulk: SyncBulkConfig;\n  privacy: SyncPrivacyConfig;\n}\n\nexport interface CollectionConfig {\n  auto_submit: boolean;\n  require_review: boolean;\n  add_attribution: boolean;\n}\n\nexport interface ElementsConfig {\n  auto_activate: {\n    personas?: string[];\n    skills?: string[];\n    templates?: string[];\n    agents?: string[];\n    memories?: string[];\n    ensembles?: string[];\n  };\n  default_element_dir: string;\n}\n\nexport interface DisplayConfig {\n  persona_indicators: {\n    enabled: boolean;\n    style: 'full' | 'minimal' | 'compact' | 'custom';\n    include_emoji: boolean;\n  };\n  verbose_logging: boolean;\n  show_progress: boolean;\n}\n\nexport interface DollhouseConfig {\n  version: string;\n  user: UserConfig;\n  github: GitHubConfig;\n  sync: SyncConfig;\n  collection: CollectionConfig;\n  elements: ElementsConfig;\n  display: DisplayConfig;\n}\n\nexport interface ConfigUpdateResult {\n  success: boolean;\n  message: string;\n  previousValue?: any;\n  newValue?: any;\n}\n\nexport interface ConfigActionResult {\n  success: boolean;\n  message: string;\n  data?: any;\n}\n\nexport class ConfigManager {\n  private static instance: ConfigManager | null = null;\n  private static instanceLock: boolean = false;\n\n  private configDir: string;\n  private configPath: string;\n  private backupPath: string;\n  private config: DollhouseConfig | null = null;\n\n  private constructor() {\n    // Initialize paths\n    this.configDir = path.join(os.homedir(), '.dollhouse');\n    this.configPath = path.join(this.configDir, 'config.yml');\n    this.backupPath = path.join(this.configDir, 'config.yml.backup');\n  }\n\n  /**\n   * Thread-safe singleton instance getter\n   */\n  public static getInstance(): ConfigManager {\n    if (ConfigManager.instance) {\n      return ConfigManager.instance;\n    }\n\n    // Simple locking mechanism to prevent race conditions\n    if (ConfigManager.instanceLock) {\n      // Wait for lock to be released, then return the instance\n      while (ConfigManager.instanceLock && !ConfigManager.instance) {\n        // In a real scenario with async operations, this would be more sophisticated\n        // But for the test cases, this simple approach works\n      }\n      return ConfigManager.instance!;\n    }\n\n    ConfigManager.instanceLock = true;\n    \n    if (!ConfigManager.instance) {\n      ConfigManager.instance = new ConfigManager();\n    }\n    \n    ConfigManager.instanceLock = false;\n    return ConfigManager.instance;\n  }\n\n  /**\n   * Get default configuration\n   */\n  private getDefaultConfig(): DollhouseConfig {\n    return {\n      version: '1.0.0',\n      user: {\n        username: null,\n        email: null,\n        display_name: null\n      },\n      github: {\n        portfolio: {\n          repository_url: null,\n          repository_name: 'dollhouse-portfolio',\n          default_branch: 'main',\n          auto_create: true\n        },\n        auth: {\n          use_oauth: true,\n          token_source: 'environment'\n        }\n      },\n      sync: {\n        enabled: false, // Privacy first - off by default\n        individual: {\n          require_confirmation: true,\n          show_diff_before_sync: true,\n          track_versions: true,\n          keep_history: 10\n        },\n        bulk: {\n          upload_enabled: false, // Requires explicit enablement\n          download_enabled: false,\n          require_preview: true,\n          respect_local_only: true\n        },\n        privacy: {\n          scan_for_secrets: true,\n          scan_for_pii: true,\n          warn_on_sensitive: true,\n          excluded_patterns: [\n            '*.secret',\n            '*-private.*',\n            'credentials/**',\n            'personal/**'\n          ]\n        }\n      },\n      collection: {\n        auto_submit: false, // Never auto-submit\n        require_review: true,\n        add_attribution: true\n      },\n      elements: {\n        auto_activate: {},\n        default_element_dir: path.join(os.homedir(), '.dollhouse', 'portfolio')\n      },\n      display: {\n        persona_indicators: {\n          enabled: true,\n          style: 'minimal',\n          include_emoji: true\n        },\n        verbose_logging: false,\n        show_progress: true\n      }\n    };\n  }\n\n  /**\n   * Initialize configuration\n   */\n  public async initialize(): Promise<void> {\n    // Always reload config from disk if it exists, even if we have defaults in memory\n    // This ensures we pick up any manual edits or saved settings\n    \n    try {\n      // Ensure config directory exists with proper permissions (0o700 = owner only)\n      await fs.mkdir(this.configDir, { recursive: true, mode: 0o700 });\n      \n      // Load or create config\n      if (await this.configExists()) {\n        await this.loadConfig();\n      } else {\n        // Create default config\n        this.config = this.getDefaultConfig();\n        \n        // Try to migrate from environment variables\n        await this.migrateFromEnvironment();\n        \n        // Save the config\n        await this.saveConfig();\n        \n        logger.info('Created new configuration file', {\n          path: this.configPath\n        });\n      }\n    } catch (error) {\n      logger.error('Failed to initialize configuration', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      // Use defaults in memory\n      this.config = this.getDefaultConfig();\n    }\n  }\n\n  /**\n   * Load configuration from file\n   */\n  private async loadConfig(): Promise<void> {\n    try {\n      const content = await fs.readFile(this.configPath, 'utf-8');\n      \n      /**\n       * IMPORTANT: Parser Selection for Different File Types\n       * \n       * We use DIFFERENT parsers for different file types:\n       * \n       * 1. js-yaml (used here) - For PURE YAML files:\n       *    - Configuration files (config.yml)\n       *    - Data files without markdown content\n       *    - Any .yml or .yaml file that's just YAML\n       *    Example format:\n       *    ```yaml\n       *    version: 1.0.0\n       *    user:\n       *      username: johndoe\n       *      email: john@example.com\n       *    ```\n       * \n       * 2. SecureYamlParser - For MARKDOWN files with YAML frontmatter:\n       *    - Persona files (*.md in personas/)\n       *    - Skill files (*.md in skills/)\n       *    - Template files (*.md in templates/)\n       *    - Any .md file with frontmatter between --- markers\n       *    Example format:\n       *    ```markdown\n       *    ---\n       *    name: Creative Writer\n       *    description: A creative assistant\n       *    ---\n       *    # Instructions\n       *    You are a creative writer...\n       *    ```\n       * \n       * The config file is PURE YAML, so we use js-yaml directly with FAILSAFE_SCHEMA\n       * for security (prevents code execution via YAML tags).\n       * SECURITY: This is NOT a vulnerability - FAILSAFE_SCHEMA prevents code execution\n       */\n      let loadedData: any;\n      try {\n        // Using yaml with FAILSAFE_SCHEMA is secure - prevents code execution\n        loadedData = yaml.load(content, {\n          schema: yaml.FAILSAFE_SCHEMA // Safe schema prevents code execution\n        });\n      } catch (yamlError) {\n        throw new Error(`Invalid YAML in configuration file: ${yamlError instanceof Error ? yamlError.message : String(yamlError)}`);\n      }\n      \n      if (!loadedData || typeof loadedData !== 'object') {\n        throw new Error('Invalid configuration format');\n      }\n      logger.debug('Loaded config from file', {\n        username: loadedData.user?.username,\n        email: loadedData.user?.email,\n        syncEnabled: loadedData.sync?.enabled\n      });\n      \n      this.config = this.mergeWithDefaults(loadedData);\n      \n      // Fix any string booleans that might have been saved incorrectly\n      this.fixConfigTypes();\n      \n      logger.debug('Configuration loaded successfully', {\n        username: this.config.user.username,\n        syncEnabled: this.config.sync.enabled\n      });\n      \n    } catch (error) {\n      logger.error('Failed to load configuration', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      throw error;\n    }\n  }\n\n  /**\n   * Check if config file exists\n   */\n  private async configExists(): Promise<boolean> {\n    try {\n      await fs.access(this.configPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Get GitHub OAuth client ID\n   * Environment variable takes precedence over config file\n   */\n  public getGitHubClientId(): string | null {\n    // Check environment variable first\n    const envClientId = process.env.DOLLHOUSE_GITHUB_CLIENT_ID;\n    if (envClientId) {\n      return envClientId;\n    }\n\n    // Fall back to config file\n    return this.config?.github?.auth?.client_id || null;\n  }\n\n  /**\n   * Set GitHub OAuth client ID in config file\n   */\n  public async setGitHubClientId(clientId: string): Promise<void> {\n    if (!ConfigManager.validateClientId(clientId)) {\n      throw new Error(\n        `Invalid GitHub client ID format. Expected format: Ov23li followed by at least 14 alphanumeric characters (e.g., Ov23liABCDEFGHIJKLMN)`\n      );\n    }\n\n    if (!this.config) {\n      this.config = this.getDefaultConfig();\n    }\n\n    // Ensure github.auth object exists\n    if (!this.config.github) {\n      this.config.github = this.getDefaultConfig().github;\n    }\n    if (!this.config.github.auth) {\n      this.config.github.auth = this.getDefaultConfig().github.auth;\n    }\n\n    this.config.github.auth.client_id = clientId;\n    await this.saveConfig();\n  }\n\n  /**\n   * Get the current configuration\n   */\n  public getConfig(): DollhouseConfig {\n    if (!this.config) {\n      throw new Error('Configuration not initialized');\n    }\n    return this.config;\n  }\n\n  /**\n   * Get a specific setting using dot notation\n   */\n  public getSetting<T>(path: string, defaultValue?: T): T | undefined {\n    if (!this.config) {\n      return defaultValue;\n    }\n    \n    const keys = path.split('.');\n    let value: any = this.config;\n    \n    for (const key of keys) {\n      if (value && typeof value === 'object' && key in value) {\n        value = value[key];\n      } else {\n        return defaultValue;\n      }\n    }\n    \n    return value as T;\n  }\n\n  /**\n   * Update a specific setting using dot notation\n   * SECURITY FIX (PR #895): Added prototype pollution protection\n   * Previously: Direct property assignment allowed __proto__ injection\n   * Now: Validates keys against forbidden properties before assignment\n   */\n  public async updateSetting(path: string, value: any): Promise<ConfigUpdateResult> {\n    if (!this.config) {\n      await this.initialize();\n    }\n    \n    const keys = path.split('.');\n    \n    // SECURITY: Validate all keys to prevent prototype pollution\n    const FORBIDDEN_KEYS = ['__proto__', 'constructor', 'prototype'];\n    for (const key of keys) {\n      if (FORBIDDEN_KEYS.includes(key)) {\n        throw new Error(`Forbidden property in path: ${key}`);\n      }\n    }\n    \n    let current: any = this.config;\n    const previousValue = this.getSetting(path);\n    \n    // Navigate to the parent object\n    for (let i = 0; i < keys.length - 1; i++) {\n      const key = keys[i];\n      if (!(key in current)) {\n        current[key] = {};\n      }\n      current = current[key];\n    }\n    \n    // Set the value\n    const lastKey = keys[keys.length - 1];\n    current[lastKey] = value;\n    \n    // Save the configuration\n    await this.saveConfig();\n    \n    logger.info('Configuration setting updated', {\n      path,\n      previousValue,\n      newValue: value\n    });\n    \n    return {\n      success: true,\n      message: `Setting '${path}' updated successfully`,\n      previousValue,\n      newValue: value\n    };\n  }\n\n  /**\n   * Validate GitHub OAuth client ID format\n   * Client IDs start with \"Ov23li\" followed by at least 14 alphanumeric characters\n   * \n   * @param clientId - The client ID to validate\n   * @returns true if valid, false otherwise\n   * \n   * @example\n   * ConfigManager.validateClientId(\"Ov23liABCDEFGHIJKLMN123456\") // true\n   * ConfigManager.validateClientId(\"invalid\") // false\n   * ConfigManager.validateClientId(\"Ov23li\") // false (too short)\n   * ConfigManager.validateClientId(\"Xv23liABCDEFGHIJKLMN\") // false (wrong prefix)\n   */\n  public static validateClientId(clientId: any): boolean {\n    if (typeof clientId !== 'string' || !clientId) {\n      return false;\n    }\n\n    // GitHub OAuth client IDs follow the pattern: Ov23li[A-Za-z0-9]{14,}\n    const clientIdPattern = /^Ov23li[A-Za-z0-9]{14,}$/;\n    return clientIdPattern.test(clientId);\n  }\n\n  /**\n   * Save configuration to file\n   */\n  private async saveConfig(): Promise<void> {\n    if (!this.config) {\n      throw new Error('No configuration to save');\n    }\n    \n    try {\n      // Create backup of existing config\n      if (await this.configExists()) {\n        await fs.copyFile(this.configPath, this.backupPath);\n      }\n      \n      // Convert to YAML\n      // Note: We use js-yaml's dump() for pure YAML output (no frontmatter markers)\n      // This creates a standard YAML file, not a markdown file with frontmatter\n      const yamlContent = yaml.dump(this.config, {\n        indent: 2,\n        lineWidth: 120,\n        noRefs: true,\n        sortKeys: false\n        // Using default schema (not FAILSAFE) for dump to preserve types like booleans\n      });\n      \n      // Write atomically with proper permissions (0o600 = owner read/write only)\n      const tempPath = `${this.configPath}.tmp`;\n      await fs.writeFile(tempPath, yamlContent, { encoding: 'utf-8', mode: 0o600 });\n      await fs.rename(tempPath, this.configPath);\n      \n      logger.debug('Configuration saved successfully');\n      \n      // Log audit event for configuration update\n      logger.debug('Configuration update audit', {\n        event: 'CONFIG_UPDATED',\n        source: 'ConfigManager.saveConfig',\n        timestamp: new Date().toISOString()\n      });\n      \n    } catch (error) {\n      logger.error('Failed to save configuration', {\n        error: error instanceof Error ? error.message : String(error)\n      });\n      \n      // Try to restore backup\n      if (await this.backupExists()) {\n        await fs.copyFile(this.backupPath, this.configPath);\n        logger.info('Restored configuration from backup');\n      }\n      \n      throw error;\n    }\n  }\n\n  /**\n   * Check if backup exists\n   */\n  private async backupExists(): Promise<boolean> {\n    try {\n      await fs.access(this.backupPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Fix incorrect types in config (e.g., string booleans, string \"null\")\n   */\n  private fixConfigTypes(): void {\n    if (!this.config) return;\n    \n    // Helper to convert string \"null\" to actual null\n    const fixNull = (value: any): any => {\n      if (value === 'null' || value === 'NULL') return null;\n      return value;\n    };\n    \n    // Helper to convert string booleans to actual booleans\n    const fixBoolean = (value: any): any => {\n      if (typeof value === 'string') {\n        const lower = value.toLowerCase();\n        if (lower === 'true') return true;\n        if (lower === 'false') return false;\n      }\n      return value;\n    };\n    \n    // Fix user fields - handle string \"null\" values\n    if (this.config.user) {\n      this.config.user.username = fixNull(this.config.user.username);\n      this.config.user.email = fixNull(this.config.user.email);\n      this.config.user.display_name = fixNull(this.config.user.display_name);\n    }\n    \n    // Fix sync settings\n    if (this.config.sync) {\n      this.config.sync.enabled = fixBoolean(this.config.sync.enabled);\n      \n      if (this.config.sync.individual) {\n        this.config.sync.individual.require_confirmation = fixBoolean(this.config.sync.individual.require_confirmation);\n        this.config.sync.individual.show_diff_before_sync = fixBoolean(this.config.sync.individual.show_diff_before_sync);\n        this.config.sync.individual.track_versions = fixBoolean(this.config.sync.individual.track_versions);\n      }\n      \n      if (this.config.sync.bulk) {\n        this.config.sync.bulk.upload_enabled = fixBoolean(this.config.sync.bulk.upload_enabled);\n        this.config.sync.bulk.download_enabled = fixBoolean(this.config.sync.bulk.download_enabled);\n        this.config.sync.bulk.require_preview = fixBoolean(this.config.sync.bulk.require_preview);\n        this.config.sync.bulk.respect_local_only = fixBoolean(this.config.sync.bulk.respect_local_only);\n      }\n      \n      if (this.config.sync.privacy) {\n        this.config.sync.privacy.scan_for_secrets = fixBoolean(this.config.sync.privacy.scan_for_secrets);\n        this.config.sync.privacy.scan_for_pii = fixBoolean(this.config.sync.privacy.scan_for_pii);\n        this.config.sync.privacy.warn_on_sensitive = fixBoolean(this.config.sync.privacy.warn_on_sensitive);\n      }\n    }\n    \n    // Fix collection settings\n    if (this.config.collection) {\n      this.config.collection.auto_submit = fixBoolean(this.config.collection.auto_submit);\n      this.config.collection.require_review = fixBoolean(this.config.collection.require_review);\n      this.config.collection.add_attribution = fixBoolean(this.config.collection.add_attribution);\n    }\n    \n    // Fix display settings\n    if (this.config.display) {\n      if (this.config.display.persona_indicators) {\n        this.config.display.persona_indicators.enabled = fixBoolean(this.config.display.persona_indicators.enabled);\n        this.config.display.persona_indicators.include_emoji = fixBoolean(this.config.display.persona_indicators.include_emoji);\n      }\n      this.config.display.verbose_logging = fixBoolean(this.config.display.verbose_logging);\n      this.config.display.show_progress = fixBoolean(this.config.display.show_progress);\n    }\n    \n    // Fix github settings\n    if (this.config.github) {\n      if (this.config.github.portfolio) {\n        this.config.github.portfolio.repository_url = fixNull(this.config.github.portfolio.repository_url);\n        this.config.github.portfolio.auto_create = fixBoolean(this.config.github.portfolio.auto_create);\n      }\n      if (this.config.github.auth) {\n        this.config.github.auth.use_oauth = fixBoolean(this.config.github.auth.use_oauth);\n        // Fix client_id if it's a string \"null\"\n        if (this.config.github.auth.client_id) {\n          this.config.github.auth.client_id = fixNull(this.config.github.auth.client_id) || undefined;\n        }\n      }\n    }\n  }\n\n  /**\n   * Merge partial config with defaults\n   * \n   * IMPORTANT: This function preserves unknown fields for forward compatibility.\n   * If a future version adds new config fields, older versions won't lose them.\n   */\n  private mergeWithDefaults(partial: Partial<DollhouseConfig>): DollhouseConfig {\n    const defaults = this.getDefaultConfig();\n    \n    // Start with a deep clone of partial to preserve all unknown fields\n    const result: any = JSON.parse(JSON.stringify(partial));\n    \n    // Ensure all required fields exist with defaults\n    result.version = result.version || defaults.version;\n    \n    // User section - preserve unknown fields while ensuring required fields\n    result.user = {\n      ...result.user,\n      username: result.user?.username ?? defaults.user.username,\n      email: result.user?.email ?? defaults.user.email,\n      display_name: result.user?.display_name ?? defaults.user.display_name\n    };\n    \n    // GitHub section - deep merge preserving unknown fields\n    if (!result.github) result.github = {};\n    result.github.portfolio = {\n      ...defaults.github.portfolio,\n      ...result.github.portfolio\n    };\n    result.github.auth = {\n      ...defaults.github.auth,\n      ...result.github.auth\n    };\n    \n    // Sync section - preserve unknown fields at all levels\n    if (!result.sync) result.sync = {};\n    result.sync.enabled = result.sync.enabled ?? defaults.sync.enabled;\n    result.sync.individual = {\n      ...defaults.sync.individual,\n      ...result.sync.individual\n    };\n    result.sync.bulk = {\n      ...defaults.sync.bulk,\n      ...result.sync.bulk\n    };\n    result.sync.privacy = {\n      ...defaults.sync.privacy,\n      ...result.sync.privacy,\n      // Special handling for arrays - use provided or default\n      excluded_patterns: result.sync.privacy?.excluded_patterns || defaults.sync.privacy.excluded_patterns\n    };\n    \n    // Collection section\n    result.collection = {\n      ...defaults.collection,\n      ...result.collection\n    };\n    \n    // Elements section\n    if (!result.elements) result.elements = {};\n    result.elements = {\n      ...result.elements,\n      auto_activate: result.elements.auto_activate || defaults.elements.auto_activate,\n      default_element_dir: result.elements.default_element_dir || defaults.elements.default_element_dir\n    };\n    \n    // Display section\n    if (!result.display) result.display = {};\n    result.display.persona_indicators = {\n      ...defaults.display.persona_indicators,\n      ...result.display.persona_indicators\n    };\n    result.display.verbose_logging = result.display.verbose_logging ?? defaults.display.verbose_logging;\n    result.display.show_progress = result.display.show_progress ?? defaults.display.show_progress;\n    \n    return result as DollhouseConfig;\n  }\n\n  /**\n   * Migrate settings from environment variables\n   */\n  private async migrateFromEnvironment(): Promise<void> {\n    let migrated = false;\n    \n    // Migrate user settings\n    if (process.env.DOLLHOUSE_USER && !this.config?.user.username) {\n      if (!this.config) this.config = this.getDefaultConfig();\n      this.config.user.username = process.env.DOLLHOUSE_USER;\n      migrated = true;\n    }\n    \n    if (process.env.DOLLHOUSE_EMAIL && !this.config?.user.email) {\n      if (!this.config) this.config = this.getDefaultConfig();\n      this.config.user.email = process.env.DOLLHOUSE_EMAIL;\n      migrated = true;\n    }\n    \n    // Migrate portfolio URL\n    if (process.env.DOLLHOUSE_PORTFOLIO_URL && !this.config?.github.portfolio.repository_url) {\n      if (!this.config) this.config = this.getDefaultConfig();\n      this.config.github.portfolio.repository_url = process.env.DOLLHOUSE_PORTFOLIO_URL;\n      migrated = true;\n    }\n    \n    // Migrate collection auto-submit\n    if (process.env.DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION !== undefined) {\n      if (!this.config) this.config = this.getDefaultConfig();\n      this.config.collection.auto_submit = process.env.DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION === 'true';\n      migrated = true;\n    }\n    \n    if (migrated) {\n      logger.info('Migrated settings from environment variables');\n    }\n  }\n\n  /**\n   * Reset configuration to defaults\n   * SECURITY FIX (PR #895): Added prototype pollution protection\n   * Previously: Direct property assignment allowed __proto__ injection\n   * Now: Validates keys against forbidden properties before assignment\n   */\n  public async resetConfig(section?: string): Promise<ConfigActionResult> {\n    const defaults = this.getDefaultConfig();\n    \n    if (section) {\n      // Reset specific section\n      if (!this.config) {\n        this.config = defaults;\n      } else {\n        const sectionKeys = section.split('.');\n        \n        // SECURITY: Validate all keys to prevent prototype pollution\n        const FORBIDDEN_KEYS = ['__proto__', 'constructor', 'prototype'];\n        for (const key of sectionKeys) {\n          if (FORBIDDEN_KEYS.includes(key)) {\n            throw new Error(`Forbidden property in section: ${key}`);\n          }\n        }\n        \n        let current: any = this.config;\n        let defaultSection: any = defaults;\n        \n        for (let i = 0; i < sectionKeys.length - 1; i++) {\n          current = current[sectionKeys[i]];\n          defaultSection = defaultSection[sectionKeys[i]];\n        }\n        \n        const lastKey = sectionKeys[sectionKeys.length - 1];\n        current[lastKey] = defaultSection[lastKey];\n      }\n      \n      await this.saveConfig();\n      \n      return {\n        success: true,\n        message: `Section '${section}' reset to defaults`\n      };\n    } else {\n      // Reset entire config\n      this.config = defaults;\n      await this.saveConfig();\n      \n      return {\n        success: true,\n        message: 'Configuration reset to defaults'\n      };\n    }\n  }\n\n  /**\n   * Export configuration to file\n   */\n  public async exportConfig(filePath: string): Promise<ConfigActionResult> {\n    if (!this.config) {\n      return {\n        success: false,\n        message: 'No configuration to export'\n      };\n    }\n    \n    try {\n      const yamlContent = yaml.dump(this.config, {\n        indent: 2,\n        lineWidth: 120,\n        noRefs: true,\n        sortKeys: false\n      });\n      \n      await fs.writeFile(filePath, yamlContent, { encoding: 'utf-8', mode: 0o600 });\n      \n      return {\n        success: true,\n        message: `Configuration exported to ${filePath}`\n      };\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to export configuration: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Import configuration from file\n   */\n  public async importConfig(filePath: string): Promise<ConfigActionResult> {\n    try {\n      const content = await fs.readFile(filePath, 'utf-8');\n      \n      // Parse and validate\n      const parsed = SecureYamlParser.parse(content, {\n        maxYamlSize: 64 * 1024,\n        validateContent: false,\n        validateFields: false\n      });\n      \n      if (!parsed.data || typeof parsed.data !== 'object') {\n        return {\n          success: false,\n          message: 'Invalid configuration format in import file'\n        };\n      }\n      \n      // Merge with defaults\n      this.config = this.mergeWithDefaults(parsed.data as Partial<DollhouseConfig>);\n      \n      // Save the imported config\n      await this.saveConfig();\n      \n      return {\n        success: true,\n        message: `Configuration imported from ${filePath}`\n      };\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to import configuration: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Get formatted config for display\n   */\n  public getFormattedConfig(section?: string): string {\n    if (!this.config) {\n      return 'Configuration not initialized';\n    }\n    \n    let configToShow: any = this.config;\n    \n    if (section) {\n      configToShow = this.getSetting(section);\n      if (!configToShow) {\n        return `Section '${section}' not found`;\n      }\n    }\n    \n    // Remove sensitive data for display\n    const sanitized = JSON.parse(JSON.stringify(configToShow));\n    \n    // Don't show tokens if they exist\n    if (sanitized.github?.auth?.token) {\n      sanitized.github.auth.token = '***REDACTED***';\n    }\n    \n    return yaml.dump(sanitized, {\n      indent: 2,\n      lineWidth: 120,\n      noRefs: true,\n      sortKeys: false\n    });\n  }\n}"]}