pomera-ai-commander 1.1.1 → 1.2.2

package/tools/curl_settings.py

@@ -1,503 +1,503 @@
-"""
-cURL Tool Settings Management Module
-
-This module provides settings persistence and management for the cURL GUI Tool.
-It handles configuration storage, loading, and validation for tool settings.
-
-Author: Pomera AI Commander
-"""
-
-import json
-import os
-from typing import Dict, Any, Optional
-import logging
-from datetime import datetime
-
-
-class CurlSettingsManager:
-    """
-    Manages settings persistence and configuration for the cURL Tool.
-    
-    Handles:
-    - Settings file storage and loading
-    - Default configuration values
-    - Settings validation
-    - Configuration backup and restore
-    """
-    
-    def __init__(self, settings_file: str = "settings.json", logger=None):
-        """
-        Initialize the settings manager.
-        
-        Args:
-            settings_file: Path to the main settings file
-            logger: Logger instance for debugging
-        """
-        self.settings_file = settings_file
-        self.logger = logger or logging.getLogger(__name__)
-        self.tool_key = "cURL Tool"  # Key in tool_settings section
-        
-        # Default settings configuration
-        self.default_settings = {
-            # Request settings
-            "default_timeout": 30,
-            "follow_redirects": True,
-            "verify_ssl": True,
-            "max_redirects": 10,
-            "user_agent": "Pomera cURL Tool/1.0",
-            
-            # History settings
-            "save_history": True,
-            "max_history_items": 100,
-            "auto_cleanup_history": True,
-            "history_retention_days": 30,
-            
-            # Authentication settings
-            "persist_auth": True,
-            "auth_timeout_minutes": 60,
-            "clear_auth_on_exit": False,
-            
-            # UI settings
-            "remember_window_size": True,
-            "default_body_type": "JSON",
-            "auto_format_json": True,
-            "syntax_highlighting": True,
-            "show_response_time": True,
-            
-            # Download settings
-            "default_download_path": "",
-            "use_remote_filename": True,
-            "resume_downloads": True,
-            "download_chunk_size": 8192,
-            
-            # Export/Import settings
-            "curl_export_format": "standard",  # standard, minimal, verbose
-            "include_comments_in_export": True,
-            "auto_escape_special_chars": True,
-            "complex_options": "",  # Additional cURL options not handled by UI
-            
-            # Debug settings
-            "enable_debug_logging": False,
-            "log_request_headers": True,
-            "log_response_headers": True,
-            "max_log_size_mb": 10,
-            
-            # Advanced settings
-            "connection_pool_size": 10,
-            "retry_attempts": 3,
-            "retry_delay_seconds": 1,
-            "enable_http2": False,
-            
-            # Version and metadata
-            "settings_version": "1.0",
-            "last_updated": None,
-            "created_date": None
-        }
-        
-        # Current settings (loaded from file or defaults)
-        self.settings = {}
-        
-        # Load settings on initialization
-        self.load_settings()
-    
-    def load_settings(self) -> Dict[str, Any]:
-        """
-        Load settings from centralized settings.json file.
-        
-        Returns:
-            Dictionary of current settings
-        """
-        try:
-            if os.path.exists(self.settings_file):
-                with open(self.settings_file, 'r', encoding='utf-8') as f:
-                    all_settings = json.load(f)
-                
-                # Get tool settings from tool_settings section
-                tool_settings = all_settings.get("tool_settings", {})
-                file_settings = tool_settings.get(self.tool_key, {})
-                
-                # Merge with defaults to ensure all keys exist
-                self.settings = self.default_settings.copy()
-                self.settings.update(file_settings)
-                
-                # Validate and fix any invalid settings
-                self._validate_settings()
-                
-                self.logger.info(f"cURL Tool settings loaded from {self.settings_file}")
-            else:
-                # Use defaults and create file
-                self.settings = self.default_settings.copy()
-                self.settings["created_date"] = datetime.now().isoformat()
-                self.save_settings()
-                self.logger.info("Created new settings file with defaults")
-                
-        except Exception as e:
-            self.logger.error(f"Error loading settings: {e}")
-            # Fall back to defaults
-            self.settings = self.default_settings.copy()
-            self.settings["created_date"] = datetime.now().isoformat()
-        
-        return self.settings
-    
-    def save_settings(self) -> bool:
-        """
-        Save current settings to centralized settings.json file.
-        
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            # Update last modified timestamp
-            self.settings["last_updated"] = datetime.now().isoformat()
-            
-            # Load existing settings file
-            all_settings = {}
-            if os.path.exists(self.settings_file):
-                with open(self.settings_file, 'r', encoding='utf-8') as f:
-                    all_settings = json.load(f)
-            
-            # Ensure tool_settings section exists
-            if "tool_settings" not in all_settings:
-                all_settings["tool_settings"] = {}
-            
-            # Update cURL Tool settings (merge with existing data to preserve history)
-            if self.tool_key not in all_settings["tool_settings"]:
-                all_settings["tool_settings"][self.tool_key] = {}
-            
-            # Preserve existing non-settings data (like history, collections)
-            existing_data = all_settings["tool_settings"][self.tool_key]
-            
-            # Update with current settings
-            all_settings["tool_settings"][self.tool_key] = {**existing_data, **self.settings}
-            
-            # Create backup of existing settings
-            self._create_backup()
-            
-            # Write settings to file
-            with open(self.settings_file, 'w', encoding='utf-8') as f:
-                json.dump(all_settings, f, indent=4, ensure_ascii=False)
-            
-            self.logger.info(f"cURL Tool settings saved to {self.settings_file}")
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Error saving settings: {e}")
-            return False
-    
-    def get_setting(self, key: str, default: Any = None) -> Any:
-        """
-        Get a setting value.
-        
-        Args:
-            key: Setting key
-            default: Default value if key not found
-            
-        Returns:
-            Setting value or default
-        """
-        return self.settings.get(key, default)
-    
-    def set_setting(self, key: str, value: Any) -> bool:
-        """
-        Set a setting value.
-        
-        Args:
-            key: Setting key
-            value: Setting value
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            # Validate the setting
-            if self._validate_setting(key, value):
-                self.settings[key] = value
-                return True
-            else:
-                self.logger.warning(f"Invalid setting value: {key} = {value}")
-                return False
-                
-        except Exception as e:
-            self.logger.error(f"Error setting {key}: {e}")
-            return False
-    
-    def reset_to_defaults(self) -> bool:
-        """
-        Reset all settings to defaults.
-        
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            # Keep creation date if it exists
-            created_date = self.settings.get("created_date")
-            
-            self.settings = self.default_settings.copy()
-            if created_date:
-                self.settings["created_date"] = created_date
-            
-            return self.save_settings()
-            
-        except Exception as e:
-            self.logger.error(f"Error resetting settings: {e}")
-            return False
-    
-    def export_settings(self, filepath: str) -> bool:
-        """
-        Export settings to a file.
-        
-        Args:
-            filepath: Path to export file
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            export_data = {
-                "settings": self.settings,
-                "export_date": datetime.now().isoformat(),
-                "version": self.settings.get("settings_version", "1.0")
-            }
-            
-            with open(filepath, 'w', encoding='utf-8') as f:
-                json.dump(export_data, f, indent=2, ensure_ascii=False)
-            
-            self.logger.info(f"Settings exported to {filepath}")
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Error exporting settings: {e}")
-            return False
-    
-    def import_settings(self, filepath: str) -> bool:
-        """
-        Import settings from a file.
-        
-        Args:
-            filepath: Path to import file
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            with open(filepath, 'r', encoding='utf-8') as f:
-                import_data = json.load(f)
-            
-            # Extract settings from import data
-            if "settings" in import_data:
-                imported_settings = import_data["settings"]
-            else:
-                # Assume the file contains settings directly
-                imported_settings = import_data
-            
-            # Merge with current settings (don't overwrite everything)
-            for key, value in imported_settings.items():
-                if key in self.default_settings:
-                    if self._validate_setting(key, value):
-                        self.settings[key] = value
-            
-            # Save the updated settings
-            return self.save_settings()
-            
-        except Exception as e:
-            self.logger.error(f"Error importing settings: {e}")
-            return False
-    
-    def get_all_settings(self) -> Dict[str, Any]:
-        """
-        Get all current settings.
-        
-        Returns:
-            Dictionary of all settings
-        """
-        return self.settings.copy()
-    
-    def get_default_settings(self) -> Dict[str, Any]:
-        """
-        Get default settings.
-        
-        Returns:
-            Dictionary of default settings
-        """
-        return self.default_settings.copy()
-    
-    def _validate_settings(self):
-        """Validate and fix invalid settings."""
-        # Ensure numeric settings are within valid ranges
-        numeric_ranges = {
-            "default_timeout": (1, 300),
-            "max_redirects": (0, 50),
-            "max_history_items": (10, 1000),
-            "history_retention_days": (1, 365),
-            "auth_timeout_minutes": (5, 1440),
-            "download_chunk_size": (1024, 1048576),
-            "connection_pool_size": (1, 100),
-            "retry_attempts": (0, 10),
-            "retry_delay_seconds": (0, 60),
-            "max_log_size_mb": (1, 100)
-        }
-        
-        for key, (min_val, max_val) in numeric_ranges.items():
-            if key in self.settings:
-                value = self.settings[key]
-                if not isinstance(value, (int, float)) or value < min_val or value > max_val:
-                    self.settings[key] = self.default_settings[key]
-                    self.logger.warning(f"Reset invalid setting {key} to default")
-        
-        # Ensure string settings are not empty where required
-        required_strings = ["user_agent", "curl_export_format", "settings_version"]
-        for key in required_strings:
-            if key in self.settings and not isinstance(self.settings[key], str):
-                self.settings[key] = self.default_settings[key]
-                self.logger.warning(f"Reset invalid string setting {key} to default")
-        
-        # Ensure boolean settings are actually boolean
-        boolean_settings = [
-            "follow_redirects", "verify_ssl", "save_history", "auto_cleanup_history",
-            "persist_auth", "clear_auth_on_exit", "remember_window_size",
-            "auto_format_json", "syntax_highlighting", "show_response_time",
-            "use_remote_filename", "resume_downloads", "include_comments_in_export",
-            "auto_escape_special_chars", "enable_debug_logging", "log_request_headers",
-            "log_response_headers", "enable_http2"
-        ]
-        
-        for key in boolean_settings:
-            if key in self.settings and not isinstance(self.settings[key], bool):
-                self.settings[key] = self.default_settings[key]
-                self.logger.warning(f"Reset invalid boolean setting {key} to default")
-    
-    def _validate_setting(self, key: str, value: Any) -> bool:
-        """
-        Validate a single setting value.
-        
-        Args:
-            key: Setting key
-            value: Setting value
-            
-        Returns:
-            True if valid, False otherwise
-        """
-        if key not in self.default_settings:
-            return False
-        
-        # Type validation
-        expected_type = type(self.default_settings[key])
-        if not isinstance(value, expected_type):
-            # Allow None for optional settings
-            if value is None and key in ["default_download_path", "last_updated", "created_date"]:
-                return True
-            return False
-        
-        # Range validation for numeric values
-        numeric_ranges = {
-            "default_timeout": (1, 300),
-            "max_redirects": (0, 50),
-            "max_history_items": (10, 1000),
-            "history_retention_days": (1, 365),
-            "auth_timeout_minutes": (5, 1440),
-            "download_chunk_size": (1024, 1048576),
-            "connection_pool_size": (1, 100),
-            "retry_attempts": (0, 10),
-            "retry_delay_seconds": (0, 60),
-            "max_log_size_mb": (1, 100)
-        }
-        
-        if key in numeric_ranges:
-            min_val, max_val = numeric_ranges[key]
-            return min_val <= value <= max_val
-        
-        # Enum validation for specific settings
-        if key == "curl_export_format":
-            return value in ["standard", "minimal", "verbose"]
-        
-        if key == "default_body_type":
-            return value in ["None", "JSON", "Form Data", "Multipart Form", "Raw Text", "Binary"]
-        
-        return True
-    
-    def _create_backup(self):
-        """Create a backup of the current settings file."""
-        try:
-            if os.path.exists(self.settings_file):
-                backup_file = f"{self.settings_file}.backup"
-                
-                # Read current file
-                with open(self.settings_file, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                
-                # Write backup
-                with open(backup_file, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                
-                self.logger.debug(f"Settings backup created: {backup_file}")
-                
-        except Exception as e:
-            self.logger.warning(f"Could not create settings backup: {e}")
-    
-    def restore_from_backup(self) -> bool:
-        """
-        Restore settings from backup file.
-        
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            backup_file = f"{self.settings_file}.backup"
-            
-            if os.path.exists(backup_file):
-                # Load backup
-                with open(backup_file, 'r', encoding='utf-8') as f:
-                    backup_settings = json.load(f)
-                
-                # Validate backup settings
-                temp_settings = self.settings.copy()
-                self.settings = backup_settings
-                self._validate_settings()
-                
-                # Save restored settings
-                if self.save_settings():
-                    self.logger.info("Settings restored from backup")
-                    return True
-                else:
-                    # Restore original settings if save failed
-                    self.settings = temp_settings
-                    return False
-            else:
-                self.logger.warning("No backup file found")
-                return False
-                
-        except Exception as e:
-            self.logger.error(f"Error restoring from backup: {e}")
-            return False
-    
-    def cleanup_old_backups(self, max_backups: int = 5):
-        """
-        Clean up old backup files.
-        
-        Args:
-            max_backups: Maximum number of backup files to keep
-        """
-        try:
-            backup_pattern = f"{self.settings_file}.backup"
-            backup_dir = os.path.dirname(self.settings_file) or "."
-            
-            # Find all backup files
-            backup_files = []
-            for filename in os.listdir(backup_dir):
-                if filename.startswith(os.path.basename(backup_pattern)):
-                    filepath = os.path.join(backup_dir, filename)
-                    backup_files.append((filepath, os.path.getmtime(filepath)))
-            
-            # Sort by modification time (newest first)
-            backup_files.sort(key=lambda x: x[1], reverse=True)
-            
-            # Remove old backups
-            for filepath, _ in backup_files[max_backups:]:
-                try:
-                    os.remove(filepath)
-                    self.logger.debug(f"Removed old backup: {filepath}")
-                except Exception as e:
-                    self.logger.warning(f"Could not remove backup {filepath}: {e}")
-                    
-        except Exception as e:
+"""
+cURL Tool Settings Management Module
+
+This module provides settings persistence and management for the cURL GUI Tool.
+It handles configuration storage, loading, and validation for tool settings.
+
+Author: Pomera AI Commander
+"""
+
+import json
+import os
+from typing import Dict, Any, Optional
+import logging
+from datetime import datetime
+
+
+class CurlSettingsManager:
+    """
+    Manages settings persistence and configuration for the cURL Tool.
+    
+    Handles:
+    - Settings file storage and loading
+    - Default configuration values
+    - Settings validation
+    - Configuration backup and restore
+    """
+    
+    def __init__(self, settings_file: str = "settings.json", logger=None):
+        """
+        Initialize the settings manager.
+        
+        Args:
+            settings_file: Path to the main settings file
+            logger: Logger instance for debugging
+        """
+        self.settings_file = settings_file
+        self.logger = logger or logging.getLogger(__name__)
+        self.tool_key = "cURL Tool"  # Key in tool_settings section
+        
+        # Default settings configuration
+        self.default_settings = {
+            # Request settings
+            "default_timeout": 30,
+            "follow_redirects": True,
+            "verify_ssl": True,
+            "max_redirects": 10,
+            "user_agent": "Pomera cURL Tool/1.0",
+            
+            # History settings
+            "save_history": True,
+            "max_history_items": 100,
+            "auto_cleanup_history": True,
+            "history_retention_days": 30,
+            
+            # Authentication settings
+            "persist_auth": True,
+            "auth_timeout_minutes": 60,
+            "clear_auth_on_exit": False,
+            
+            # UI settings
+            "remember_window_size": True,
+            "default_body_type": "JSON",
+            "auto_format_json": True,
+            "syntax_highlighting": True,
+            "show_response_time": True,
+            
+            # Download settings
+            "default_download_path": "",
+            "use_remote_filename": True,
+            "resume_downloads": True,
+            "download_chunk_size": 8192,
+            
+            # Export/Import settings
+            "curl_export_format": "standard",  # standard, minimal, verbose
+            "include_comments_in_export": True,
+            "auto_escape_special_chars": True,
+            "complex_options": "",  # Additional cURL options not handled by UI
+            
+            # Debug settings
+            "enable_debug_logging": False,
+            "log_request_headers": True,
+            "log_response_headers": True,
+            "max_log_size_mb": 10,
+            
+            # Advanced settings
+            "connection_pool_size": 10,
+            "retry_attempts": 3,
+            "retry_delay_seconds": 1,
+            "enable_http2": False,
+            
+            # Version and metadata
+            "settings_version": "1.0",
+            "last_updated": None,
+            "created_date": None
+        }
+        
+        # Current settings (loaded from file or defaults)
+        self.settings = {}
+        
+        # Load settings on initialization
+        self.load_settings()
+    
+    def load_settings(self) -> Dict[str, Any]:
+        """
+        Load settings from centralized settings.json file.
+        
+        Returns:
+            Dictionary of current settings
+        """
+        try:
+            if os.path.exists(self.settings_file):
+                with open(self.settings_file, 'r', encoding='utf-8') as f:
+                    all_settings = json.load(f)
+                
+                # Get tool settings from tool_settings section
+                tool_settings = all_settings.get("tool_settings", {})
+                file_settings = tool_settings.get(self.tool_key, {})
+                
+                # Merge with defaults to ensure all keys exist
+                self.settings = self.default_settings.copy()
+                self.settings.update(file_settings)
+                
+                # Validate and fix any invalid settings
+                self._validate_settings()
+                
+                self.logger.info(f"cURL Tool settings loaded from {self.settings_file}")
+            else:
+                # Use defaults and create file
+                self.settings = self.default_settings.copy()
+                self.settings["created_date"] = datetime.now().isoformat()
+                self.save_settings()
+                self.logger.info("Created new settings file with defaults")
+                
+        except Exception as e:
+            self.logger.error(f"Error loading settings: {e}")
+            # Fall back to defaults
+            self.settings = self.default_settings.copy()
+            self.settings["created_date"] = datetime.now().isoformat()
+        
+        return self.settings
+    
+    def save_settings(self) -> bool:
+        """
+        Save current settings to centralized settings.json file.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Update last modified timestamp
+            self.settings["last_updated"] = datetime.now().isoformat()
+            
+            # Load existing settings file
+            all_settings = {}
+            if os.path.exists(self.settings_file):
+                with open(self.settings_file, 'r', encoding='utf-8') as f:
+                    all_settings = json.load(f)
+            
+            # Ensure tool_settings section exists
+            if "tool_settings" not in all_settings:
+                all_settings["tool_settings"] = {}
+            
+            # Update cURL Tool settings (merge with existing data to preserve history)
+            if self.tool_key not in all_settings["tool_settings"]:
+                all_settings["tool_settings"][self.tool_key] = {}
+            
+            # Preserve existing non-settings data (like history, collections)
+            existing_data = all_settings["tool_settings"][self.tool_key]
+            
+            # Update with current settings
+            all_settings["tool_settings"][self.tool_key] = {**existing_data, **self.settings}
+            
+            # Create backup of existing settings
+            self._create_backup()
+            
+            # Write settings to file
+            with open(self.settings_file, 'w', encoding='utf-8') as f:
+                json.dump(all_settings, f, indent=4, ensure_ascii=False)
+            
+            self.logger.info(f"cURL Tool settings saved to {self.settings_file}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Error saving settings: {e}")
+            return False
+    
+    def get_setting(self, key: str, default: Any = None) -> Any:
+        """
+        Get a setting value.
+        
+        Args:
+            key: Setting key
+            default: Default value if key not found
+            
+        Returns:
+            Setting value or default
+        """
+        return self.settings.get(key, default)
+    
+    def set_setting(self, key: str, value: Any) -> bool:
+        """
+        Set a setting value.
+        
+        Args:
+            key: Setting key
+            value: Setting value
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Validate the setting
+            if self._validate_setting(key, value):
+                self.settings[key] = value
+                return True
+            else:
+                self.logger.warning(f"Invalid setting value: {key} = {value}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"Error setting {key}: {e}")
+            return False
+    
+    def reset_to_defaults(self) -> bool:
+        """
+        Reset all settings to defaults.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Keep creation date if it exists
+            created_date = self.settings.get("created_date")
+            
+            self.settings = self.default_settings.copy()
+            if created_date:
+                self.settings["created_date"] = created_date
+            
+            return self.save_settings()
+            
+        except Exception as e:
+            self.logger.error(f"Error resetting settings: {e}")
+            return False
+    
+    def export_settings(self, filepath: str) -> bool:
+        """
+        Export settings to a file.
+        
+        Args:
+            filepath: Path to export file
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            export_data = {
+                "settings": self.settings,
+                "export_date": datetime.now().isoformat(),
+                "version": self.settings.get("settings_version", "1.0")
+            }
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(export_data, f, indent=2, ensure_ascii=False)
+            
+            self.logger.info(f"Settings exported to {filepath}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Error exporting settings: {e}")
+            return False
+    
+    def import_settings(self, filepath: str) -> bool:
+        """
+        Import settings from a file.
+        
+        Args:
+            filepath: Path to import file
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                import_data = json.load(f)
+            
+            # Extract settings from import data
+            if "settings" in import_data:
+                imported_settings = import_data["settings"]
+            else:
+                # Assume the file contains settings directly
+                imported_settings = import_data
+            
+            # Merge with current settings (don't overwrite everything)
+            for key, value in imported_settings.items():
+                if key in self.default_settings:
+                    if self._validate_setting(key, value):
+                        self.settings[key] = value
+            
+            # Save the updated settings
+            return self.save_settings()
+            
+        except Exception as e:
+            self.logger.error(f"Error importing settings: {e}")
+            return False
+    
+    def get_all_settings(self) -> Dict[str, Any]:
+        """
+        Get all current settings.
+        
+        Returns:
+            Dictionary of all settings
+        """
+        return self.settings.copy()
+    
+    def get_default_settings(self) -> Dict[str, Any]:
+        """
+        Get default settings.
+        
+        Returns:
+            Dictionary of default settings
+        """
+        return self.default_settings.copy()
+    
+    def _validate_settings(self):
+        """Validate and fix invalid settings."""
+        # Ensure numeric settings are within valid ranges
+        numeric_ranges = {
+            "default_timeout": (1, 300),
+            "max_redirects": (0, 50),
+            "max_history_items": (10, 1000),
+            "history_retention_days": (1, 365),
+            "auth_timeout_minutes": (5, 1440),
+            "download_chunk_size": (1024, 1048576),
+            "connection_pool_size": (1, 100),
+            "retry_attempts": (0, 10),
+            "retry_delay_seconds": (0, 60),
+            "max_log_size_mb": (1, 100)
+        }
+        
+        for key, (min_val, max_val) in numeric_ranges.items():
+            if key in self.settings:
+                value = self.settings[key]
+                if not isinstance(value, (int, float)) or value < min_val or value > max_val:
+                    self.settings[key] = self.default_settings[key]
+                    self.logger.warning(f"Reset invalid setting {key} to default")
+        
+        # Ensure string settings are not empty where required
+        required_strings = ["user_agent", "curl_export_format", "settings_version"]
+        for key in required_strings:
+            if key in self.settings and not isinstance(self.settings[key], str):
+                self.settings[key] = self.default_settings[key]
+                self.logger.warning(f"Reset invalid string setting {key} to default")
+        
+        # Ensure boolean settings are actually boolean
+        boolean_settings = [
+            "follow_redirects", "verify_ssl", "save_history", "auto_cleanup_history",
+            "persist_auth", "clear_auth_on_exit", "remember_window_size",
+            "auto_format_json", "syntax_highlighting", "show_response_time",
+            "use_remote_filename", "resume_downloads", "include_comments_in_export",
+            "auto_escape_special_chars", "enable_debug_logging", "log_request_headers",
+            "log_response_headers", "enable_http2"
+        ]
+        
+        for key in boolean_settings:
+            if key in self.settings and not isinstance(self.settings[key], bool):
+                self.settings[key] = self.default_settings[key]
+                self.logger.warning(f"Reset invalid boolean setting {key} to default")
+    
+    def _validate_setting(self, key: str, value: Any) -> bool:
+        """
+        Validate a single setting value.
+        
+        Args:
+            key: Setting key
+            value: Setting value
+            
+        Returns:
+            True if valid, False otherwise
+        """
+        if key not in self.default_settings:
+            return False
+        
+        # Type validation
+        expected_type = type(self.default_settings[key])
+        if not isinstance(value, expected_type):
+            # Allow None for optional settings
+            if value is None and key in ["default_download_path", "last_updated", "created_date"]:
+                return True
+            return False
+        
+        # Range validation for numeric values
+        numeric_ranges = {
+            "default_timeout": (1, 300),
+            "max_redirects": (0, 50),
+            "max_history_items": (10, 1000),
+            "history_retention_days": (1, 365),
+            "auth_timeout_minutes": (5, 1440),
+            "download_chunk_size": (1024, 1048576),
+            "connection_pool_size": (1, 100),
+            "retry_attempts": (0, 10),
+            "retry_delay_seconds": (0, 60),
+            "max_log_size_mb": (1, 100)
+        }
+        
+        if key in numeric_ranges:
+            min_val, max_val = numeric_ranges[key]
+            return min_val <= value <= max_val
+        
+        # Enum validation for specific settings
+        if key == "curl_export_format":
+            return value in ["standard", "minimal", "verbose"]
+        
+        if key == "default_body_type":
+            return value in ["None", "JSON", "Form Data", "Multipart Form", "Raw Text", "Binary"]
+        
+        return True
+    
+    def _create_backup(self):
+        """Create a backup of the current settings file."""
+        try:
+            if os.path.exists(self.settings_file):
+                backup_file = f"{self.settings_file}.backup"
+                
+                # Read current file
+                with open(self.settings_file, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Write backup
+                with open(backup_file, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                
+                self.logger.debug(f"Settings backup created: {backup_file}")
+                
+        except Exception as e:
+            self.logger.warning(f"Could not create settings backup: {e}")
+    
+    def restore_from_backup(self) -> bool:
+        """
+        Restore settings from backup file.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            backup_file = f"{self.settings_file}.backup"
+            
+            if os.path.exists(backup_file):
+                # Load backup
+                with open(backup_file, 'r', encoding='utf-8') as f:
+                    backup_settings = json.load(f)
+                
+                # Validate backup settings
+                temp_settings = self.settings.copy()
+                self.settings = backup_settings
+                self._validate_settings()
+                
+                # Save restored settings
+                if self.save_settings():
+                    self.logger.info("Settings restored from backup")
+                    return True
+                else:
+                    # Restore original settings if save failed
+                    self.settings = temp_settings
+                    return False
+            else:
+                self.logger.warning("No backup file found")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"Error restoring from backup: {e}")
+            return False
+    
+    def cleanup_old_backups(self, max_backups: int = 5):
+        """
+        Clean up old backup files.
+        
+        Args:
+            max_backups: Maximum number of backup files to keep
+        """
+        try:
+            backup_pattern = f"{self.settings_file}.backup"
+            backup_dir = os.path.dirname(self.settings_file) or "."
+            
+            # Find all backup files
+            backup_files = []
+            for filename in os.listdir(backup_dir):
+                if filename.startswith(os.path.basename(backup_pattern)):
+                    filepath = os.path.join(backup_dir, filename)
+                    backup_files.append((filepath, os.path.getmtime(filepath)))
+            
+            # Sort by modification time (newest first)
+            backup_files.sort(key=lambda x: x[1], reverse=True)
+            
+            # Remove old backups
+            for filepath, _ in backup_files[max_backups:]:
+                try:
+                    os.remove(filepath)
+                    self.logger.debug(f"Removed old backup: {filepath}")
+                except Exception as e:
+                    self.logger.warning(f"Could not remove backup {filepath}: {e}")
+                    
+        except Exception as e:
             self.logger.warning(f"Error cleaning up backups: {e}")