iotsploit-core 0.0.6__tar.gz → 0.0.7__tar.gz

{iotsploit_core-0.0.6 → iotsploit_core-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: iotsploit-core
-Version: 0.0.6
+Version: 0.0.7
 Summary: IoTSploit core library (domain + ports + core) - IoT security testing framework
 License: GPL-3.0-or-later
 Keywords: iot,security,testing,pentest,vulnerability
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Security
 Classifier: Topic :: System :: Hardware
 Requires-Dist: dataclasses-json (>=0.6.3,<0.7.0)

{iotsploit_core-0.0.6 → iotsploit_core-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "iotsploit-core"
-version = "0.0.6"
+version = "0.0.7"
 description = "IoTSploit core library (domain + ports + core) - IoT security testing framework"
 authors = ["IoTSploit Team <support@iotsploit.org>"]
 readme = "README.md"

{iotsploit_core-0.0.6 → iotsploit_core-0.0.7}/src/iotsploit_core/core/execution_backend.py

@@ -439,7 +439,15 @@ class ExecutionBackendManager:
     def list_available_backends(self) -> List[str]:
         """List all available backends"""
         return list(self.backends.keys())
-    
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get status of all execution backends"""
+        return {
+            'default_backend': self.default_backend,
+            'available_backends': self.list_available_backends(),
+            'total_backends': len(self.backends),
+        }
+
     def set_default_backend(self, name: str):
         """Set default execution backend"""
         if name not in self.backends:

{iotsploit_core-0.0.6 → iotsploit_core-0.0.7}/src/iotsploit_core/core/tool_manager.py

@@ -11,7 +11,7 @@ import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Dict, List, Optional, Union, Any, Tuple
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, asdict
 from enum import Enum
 import threading
 import time
@@ -24,6 +24,20 @@ from .execution_queue import get_execution_queue, TaskPriority
 
 logger = logging.getLogger(__name__)
 
+# Detection results older than this (seconds) are re-probed; fresh ones are served
+# from the runtime cache instead of re-running every tool's `--version`.
+TOOL_CACHE_TTL_SECONDS = 3600
+
+# Curated, version-controlled fields. These live in conf/tools.json and are never
+# rewritten by runtime detection.
+STATIC_TOOL_FIELDS = (
+    "name", "aliases", "dependencies", "platforms",
+    "min_version", "max_version", "metadata",
+)
+# Machine-specific detection results. These live in the gitignored runtime cache
+# (.tools_cache.json) because they differ per host and change on every probe.
+RUNTIME_TOOL_FIELDS = ("path", "version", "status", "last_checked")
+
 class ToolStatus(Enum):
     """Tool availability status"""
     AVAILABLE = "available"
@@ -77,6 +91,8 @@ class ToolRegistry:
     def __init__(self, config_path: Optional[str] = None):
         self.tools: Dict[str, ToolInfo] = {}
         self.config_path = config_path or self._get_default_config_path()
+        # Runtime detection cache lives next to the config but is gitignored.
+        self.cache_path = str(Path(self.config_path).parent / ".tools_cache.json")
         self._lock = threading.RLock()
         self._load_config()
     
@@ -93,25 +109,30 @@ class ToolRegistry:
         return str(config_dir / "tools.json")
     
     def _load_config(self):
-        """Load tool configuration from file"""
+        """Load curated tool definitions from the version-controlled config file."""
         if os.path.exists(self.config_path):
             try:
                 with open(self.config_path, 'r') as f:
                     config = json.load(f)
-                    for tool_name, tool_data in config.get('tools', {}).items():
-                        # Convert status string back to enum if needed
-                        if 'status' in tool_data and isinstance(tool_data['status'], str):
-                            try:
-                                tool_data['status'] = ToolStatus(tool_data['status'])
-                            except ValueError:
-                                # If status string is invalid, default to MISSING
-                                tool_data['status'] = ToolStatus.MISSING
-                        self.tools[tool_name] = ToolInfo(**tool_data)
-                logger.info(f"Loaded {len(self.tools)} tools from config")
+                known_fields = set(STATIC_TOOL_FIELDS) | set(RUNTIME_TOOL_FIELDS)
+                for tool_name, tool_data in config.get('tools', {}).items():
+                    # Tolerate legacy files that still carry runtime fields, and drop
+                    # any unknown keys so the ToolInfo constructor never fails.
+                    data = {k: v for k, v in tool_data.items() if k in known_fields}
+                    data.setdefault('name', tool_name)
+                    if isinstance(data.get('status'), str):
+                        try:
+                            data['status'] = ToolStatus(data['status'])
+                        except ValueError:
+                            data['status'] = ToolStatus.MISSING
+                    self.tools[tool_name] = ToolInfo(**data)
+                logger.info(f"Loaded {len(self.tools)} tool definitions from config")
             except Exception as e:
                 logger.error(f"Failed to load tool config: {e}")
         else:
             self._create_default_config()
+        # Overlay machine-specific detection results from the runtime cache.
+        self._load_cache()
     
     def _create_default_config(self):
         """Create default tool configuration"""
@@ -154,36 +175,80 @@ class ToolRegistry:
         
         self.save_config()
     
+    def _load_cache(self):
+        """Overlay machine-specific detection results from the runtime cache onto
+        the loaded definitions. A missing or unreadable cache is normal."""
+        if not os.path.exists(self.cache_path):
+            return
+        try:
+            with open(self.cache_path, 'r') as f:
+                cache = json.load(f)
+        except Exception as e:
+            logger.warning(f"Ignoring unreadable tool cache {self.cache_path}: {e}")
+            return
+        for name, runtime in cache.get('tools', {}).items():
+            tool = self.tools.get(name)
+            if not tool:
+                continue
+            if 'path' in runtime:
+                tool.path = runtime['path']
+            if 'version' in runtime:
+                tool.version = runtime['version']
+            if 'last_checked' in runtime:
+                tool.last_checked = runtime['last_checked']
+            if isinstance(runtime.get('status'), str):
+                try:
+                    tool.status = ToolStatus(runtime['status'])
+                except ValueError:
+                    tool.status = ToolStatus.MISSING
+
     def save_config(self):
-        """Save tool configuration to file"""
+        """Persist the curated tool definitions (static fields only).
+
+        Detection results are intentionally excluded — they belong in the runtime
+        cache (see save_cache) so this version-controlled file stays stable across
+        hosts and process restarts. Call this only when a definition changes."""
         try:
             config = {
+                'tools': {
+                    name: {field: getattr(tool, field) for field in STATIC_TOOL_FIELDS}
+                    for name, tool in self.tools.items()
+                }
+            }
+            with open(self.config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+            logger.debug(f"Saved tool definitions to {self.config_path}")
+        except Exception as e:
+            logger.error(f"Failed to save tool config: {e}")
+            import traceback
+            logger.debug(f"Save config traceback: {traceback.format_exc()}")
+
+    def save_cache(self):
+        """Persist machine-specific detection results to the gitignored runtime cache.
+
+        path/version/status/last_checked differ per host and change on every probe,
+        so they must never land in the version-controlled tools.json."""
+        try:
+            cache = {
                 'tools': {
                     name: {
-                        'name': tool.name,
                         'path': tool.path,
                         'version': tool.version,
                         'status': tool.status.value if hasattr(tool.status, 'value') else str(tool.status),
-                        'aliases': tool.aliases,
-                        'dependencies': tool.dependencies,
-                        'platforms': tool.platforms,
-                        'min_version': tool.min_version,
-                        'max_version': tool.max_version,
                         'last_checked': tool.last_checked,
-                        'metadata': tool.metadata
                     }
                     for name, tool in self.tools.items()
                 }
             }
-            
-            with open(self.config_path, 'w') as f:
-                json.dump(config, f, indent=2)
-            logger.debug(f"Saved tool config to {self.config_path}")
+            Path(self.cache_path).parent.mkdir(parents=True, exist_ok=True)
+            # Guarded by self._lock against threads, but not against multiple
+            # processes sharing one cache file. TODO: add file locking if iotsploit
+            # is ever run as concurrent processes against the same cache.
+            with open(self.cache_path, 'w') as f:
+                json.dump(cache, f, indent=2)
+            logger.debug(f"Saved tool runtime cache to {self.cache_path}")
         except Exception as e:
-            logger.error(f"Failed to save tool config: {e}")
-            # Add more detailed error information
-            import traceback
-            logger.debug(f"Save config traceback: {traceback.format_exc()}")
+            logger.error(f"Failed to save tool cache: {e}")
     
     def register_tool(self, tool_info: ToolInfo, save_config: bool = True):
         """Register a new tool"""
@@ -477,8 +542,8 @@ class ToolManager:
             validated_tool = self.validator.validate_tool(tool_info)
             self.registry.tools[tool_name] = validated_tool
             results[tool_name] = validated_tool.status
-        
-        self.registry.save_config()
+
+        self.registry.save_cache()
         return results
     
     def get_tool_status(self, tool_name: str) -> Optional[ToolStatus]:
@@ -488,11 +553,11 @@ class ToolManager:
             return None
         
         # Refresh status if not checked recently
-        if not tool_info.last_checked or (time.time() - tool_info.last_checked) > 3600:
+        if not tool_info.last_checked or (time.time() - tool_info.last_checked) > TOOL_CACHE_TTL_SECONDS:
             tool_info = self.validator.validate_tool(tool_info)
             self.registry.tools[tool_info.name] = tool_info
-            self.registry.save_config()
-        
+            self.registry.save_cache()
+
         return tool_info.status
     
     def execute(self, tool_name: str, args: List[str], **kwargs) -> ExecutionResult:
@@ -525,91 +590,50 @@ class ToolManager:
         # Validate the tool
         validated_tool = self.validator.validate_tool(tool_info)
         self.registry.register_tool(validated_tool, save_config=save_config)
-        
+        if save_config:
+            # Persisting a new tool also persists its freshly-probed runtime state.
+            self.registry.save_cache()
+
         return validated_tool.status == ToolStatus.AVAILABLE
     
     # ========== Methods from ToolCategoryManager ==========
     
     def _initialize_tools(self):
-        """Initialize all tools from JSON configuration"""
-        logger.info("Initializing tools from JSON config")
-        
-        # Get tools from the main tools.json file
-        tool_configs = self.config_manager.get_tools_by_category("tools")
-        
-        # If no tools found in "tools" category, try loading from the main config
-        if not tool_configs:
-            # Try to load from tools.json in conf directory first, then fallback
-            tools_file = Path('conf') / 'tools.json'
-            if not tools_file.exists():
-                tools_file = self.config_manager.config_dir / "tools.json"
-            
-            if tools_file.exists():
-                with open(tools_file, 'r', encoding='utf-8') as f:
-                    tools_data = json.load(f)
-                
-                tools_added = 0
-                # Support tools field as dict or list
-                tools_section = tools_data.get('tools', [])
-                if isinstance(tools_section, dict):
-                    items = tools_section.items()
-                else:
-                    items = [(td.get('name', 'unknown'), td) for td in tools_section if isinstance(td, dict)]
-                for tool_name, tool_data in items:
-                    try:
-                        # Build tool_data dict and ensure it contains name
-                        data = tool_data.copy() if isinstance(tool_data, dict) else {}
-                        data.setdefault('name', tool_name)
-                        tool_config = ToolConfig.from_dict(data)
-                        tool_config.category = "tools"
-                        # Add tool to manager (don't save config for each tool)
-                        success = self.add_tool(
-                            name=tool_config.name,
-                            aliases=tool_config.aliases,
-                            min_version=tool_config.min_version,
-                            platforms=tool_config.platforms,
-                            path=tool_config.path,
-                            save_config=False
-                        )
-                        if success:
-                            tools_added += 1
-                            logger.debug(f"Added tool: {tool_config.name}")
-                        else:
-                            logger.warning(f"Failed to add tool: {tool_config.name}")
-                    except Exception as e:
-                        logger.error(f"Error adding tool {tool_name}: {e}")
-                
-                # Save config once at the end
-                if tools_added > 0:
-                    self.registry.save_config()
-                    logger.info(f"Successfully initialized {tools_added} tools")
-        else:
-            # Load tools from category
-            tools_added = 0
-            for tool_config in tool_configs:
+        """Validate registered tools, honoring the runtime cache so tools probed
+        recently are not re-probed on every startup."""
+        logger.info("Initializing tools from configuration")
+
+        # The registry already loaded curated definitions (and any cached runtime
+        # state) from tools.json. If it came up empty, fall back to the category
+        # manager as the definition source.
+        if not self.registry.tools:
+            for tool_config in self.config_manager.get_tools_by_category("tools"):
                 try:
-                    success = self.add_tool(
+                    self.registry.tools[tool_config.name] = ToolInfo(
                         name=tool_config.name,
-                        aliases=tool_config.aliases,
-                        min_version=tool_config.min_version,
-                        platforms=tool_config.platforms,
                         path=tool_config.path,
-                        save_config=False  # Don't save for each tool
+                        aliases=tool_config.aliases or [],
+                        min_version=tool_config.min_version,
+                        platforms=tool_config.platforms or ["linux", "darwin", "windows"],
                     )
-                    
-                    if success:
-                        tools_added += 1
-                        logger.debug(f"Added tool: {tool_config.name}")
-                    else:
-                        logger.warning(f"Failed to add tool: {tool_config.name}")
-                        
                 except Exception as e:
                     logger.error(f"Error adding tool {tool_config.name}: {e}")
-            
-            # Save config once at the end
-            if tools_added > 0:
-                self.registry.save_config()
-                logger.info(f"Successfully initialized {tools_added} tools")
+
+        now = time.time()
+        revalidated = 0
+        for name, tool_info in list(self.registry.tools.items()):
+            # Skip tools whose cached detection result is still fresh.
+            if tool_info.last_checked and (now - tool_info.last_checked) < TOOL_CACHE_TTL_SECONDS:
+                continue
+            self.registry.tools[name] = self.validator.validate_tool(tool_info)
+            revalidated += 1
+
+        # Only touch the runtime cache when something was actually re-probed.
+        if revalidated:
+            self.registry.save_cache()
+        logger.info(
+            f"Initialized {len(self.registry.tools)} tools ({revalidated} re-probed)"
+        )
     
     def get_category_info(self) -> CategoryInfo:
         """Get category information from JSON config"""
@@ -883,7 +907,7 @@ class ToolManager:
             },
             'recommendations': status.recommendations,
             'backend_status': self.backend_manager.get_status(),
-            'queue_status': self.queue_manager.get_stats()
+            'queue_status': asdict(self.queue_manager.get_stats())
         }
         
         return report

{iotsploit_core-0.0.6 → iotsploit_core-0.0.7}/src/iotsploit_core/core/tool_service.py

@@ -594,37 +594,193 @@ class GreatFETProgrammer(BaseProgrammer):
         return self.execute_tool('greatfet_firmware', args, timeout=300)
 
 class FirmwareToolService(ToolService):
-    """Tool service specialized for firmware operations"""
-    
+    """Tool service specialized for firmware operations.
+
+    Manifest resolution order (later entries override earlier ones):
+      1. Built-in manifest shipped inside the ``iotsploit_drivers`` package at
+         ``resources/firmware_manifest.json``.
+      2. User override manifest at ``~/.iotsploit/firmware_manifest.json``
+         (also where runtime-added firmware entries are persisted).
+
+    Firmware entries may reference their binary in two ways:
+      * ``"resource": "<package>:<relpath>"`` — a logical reference resolved
+        via :func:`importlib.resources.as_file`. Preferred for bundled
+        defaults so wheels and editable installs both work.
+      * ``"path": "<filesystem path>"`` — a plain filesystem path. Intended
+        for user-added firmware.
+
+    Multi-file entries may use ``flash_options.files`` where each item has
+    either ``"resource"`` or ``"path"``.
+
+    Call :meth:`resolve_firmware` to obtain a context manager that yields
+    a dict with all ``resource`` entries materialized to real filesystem
+    paths — required for subprocess tools like ``esptool`` and
+    ``openFPGALoader`` that need a concrete path on disk.
+    """
+
+    #: Name of the built-in manifest resource inside iotsploit_drivers.
+    _BUILTIN_MANIFEST_PACKAGE = "iotsploit_drivers"
+    _BUILTIN_MANIFEST_RELPATH = "resources/firmware_manifest.json"
+
     def __init__(self):
         super().__init__()
-        
-        # Initialize firmware registry
+
         from pathlib import Path
-        import json
-        # Use centralized configuration directory
-        self.conf_dir = Path('conf')
-        self.conf_dir.mkdir(exist_ok=True)
-        self.manifest_file = self.conf_dir / 'firmware_manifest.json'
+
+        # User directory for overrides and runtime-added firmware.
+        self.user_dir = Path.home() / ".iotsploit"
+        self.user_dir.mkdir(exist_ok=True)
+        self.user_manifest_file = self.user_dir / "firmware_manifest.json"
+
         self.manifests = self._load_manifests()
-        
+
         # Initialize programmers
         self.esp32 = ESP32Programmer(self)
         self.stm32 = STM32Programmer(self)
         self.dfu = DFUProgrammer(self)
         self.fpga = FPGAProgrammer(self)
         self.greatfet = GreatFETProgrammer(self)
-    
+
+    # ------------------------------------------------------------------
+    # Manifest loading
+    # ------------------------------------------------------------------
+
+    def _load_builtin_manifest(self) -> Dict:
+        """Load the manifest shipped inside the iotsploit_drivers package."""
+        try:
+            from importlib.resources import files
+        except ImportError:  # pragma: no cover - Python <3.9 not supported
+            return {}
+
+        try:
+            traversable = files(self._BUILTIN_MANIFEST_PACKAGE).joinpath(
+                self._BUILTIN_MANIFEST_RELPATH
+            )
+            data = json.loads(traversable.read_text(encoding="utf-8"))
+        except (ModuleNotFoundError, FileNotFoundError):
+            self.logger.warning(
+                "Built-in firmware manifest not found in %s:%s",
+                self._BUILTIN_MANIFEST_PACKAGE,
+                self._BUILTIN_MANIFEST_RELPATH,
+            )
+            return {}
+        except json.JSONDecodeError as exc:
+            self.logger.error("Built-in firmware manifest is invalid JSON: %s", exc)
+            return {}
+
+        # Drop schema metadata key if present.
+        data.pop("_schema", None)
+        return data
+
+    def _load_user_manifest(self) -> Dict:
+        """Load the user override manifest from ~/.iotsploit."""
+        if not self.user_manifest_file.exists():
+            return {}
+        try:
+            with open(self.user_manifest_file, "r") as f:
+                data = json.load(f)
+        except json.JSONDecodeError as exc:
+            self.logger.error(
+                "User firmware manifest %s is invalid JSON: %s",
+                self.user_manifest_file,
+                exc,
+            )
+            return {}
+        data.pop("_schema", None)
+        return data
+
     def _load_manifests(self) -> Dict:
-        """Load firmware manifests from JSON file"""
-        if self.manifest_file.exists():
-            try:
-                with open(self.manifest_file, 'r') as f:
-                    return json.load(f)
-            except json.JSONDecodeError:
-                self.logger.error("Error loading firmware manifest file")
-                return {}
-        return {}
+        """Merge built-in and user manifests. User entries take precedence."""
+        merged: Dict = {}
+        merged.update(self._load_builtin_manifest())
+        merged.update(self._load_user_manifest())
+        return merged
+
+    # ------------------------------------------------------------------
+    # Firmware resolution
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _parse_resource_ref(resource_ref: str):
+        """Parse ``"<package>:<relpath>"`` into its components."""
+        if ":" not in resource_ref:
+            raise ValueError(
+                f"Invalid resource ref {resource_ref!r}; "
+                f"expected '<package>:<relpath>'"
+            )
+        package, relpath = resource_ref.split(":", 1)
+        package = package.strip()
+        relpath = relpath.strip().lstrip("/")
+        if not package or not relpath:
+            raise ValueError(f"Invalid resource ref {resource_ref!r}")
+        return package, relpath
+
+    @classmethod
+    def _resource_as_path(cls, resource_ref: str):
+        """Return a context manager yielding a concrete Path for a resource ref.
+
+        Uses :func:`importlib.resources.as_file` so resources packed inside
+        zipped wheels are materialized to a temp file for the duration of the
+        ``with`` block.
+        """
+        from importlib.resources import files, as_file
+
+        package, relpath = cls._parse_resource_ref(resource_ref)
+        traversable = files(package).joinpath(relpath)
+        return as_file(traversable)
+
+    def resolve_firmware(self, name: str):
+        """Context manager yielding a firmware_info dict with real paths.
+
+        The yielded dict is a shallow copy of the manifest entry where:
+          * ``resource`` has been replaced by ``path`` (a real filesystem str)
+          * ``flash_options.files[*].resource`` has been replaced by ``path``
+
+        All temporary files (if any) are kept alive for the duration of the
+        ``with`` block. Raises :class:`KeyError` if ``name`` is not in the
+        manifest.
+        """
+        from contextlib import contextmanager, ExitStack
+        from pathlib import Path
+
+        info = self.manifests.get(name)
+        if info is None:
+            raise KeyError(f"Firmware {name!r} not found in manifest")
+
+        @contextmanager
+        def _ctx():
+            with ExitStack() as stack:
+                resolved = dict(info)
+
+                # Top-level resource/path.
+                if "resource" in info:
+                    p = stack.enter_context(self._resource_as_path(info["resource"]))
+                    resolved["path"] = str(p)
+                    resolved.pop("resource", None)
+                elif "path" in info:
+                    resolved["path"] = str(info["path"])
+
+                # flash_options.files[*]
+                flash_options = dict(info.get("flash_options", {}))
+                if "files" in flash_options:
+                    new_files = []
+                    for entry in flash_options["files"]:
+                        new_entry = dict(entry)
+                        if "resource" in entry:
+                            p = stack.enter_context(
+                                self._resource_as_path(entry["resource"])
+                            )
+                            new_entry["path"] = str(p)
+                            new_entry.pop("resource", None)
+                        elif "path" in entry:
+                            new_entry["path"] = str(entry["path"])
+                        new_files.append(new_entry)
+                    flash_options["files"] = new_files
+
+                resolved["flash_options"] = flash_options
+                yield resolved
+
+        return _ctx()
     
     def add_firmware(self, name: str, path: str, device_type: str, version: str, 
                     flash_options: Optional[Dict[str, Any]] = None) -> bool:
@@ -690,7 +846,9 @@ class FirmwareToolService(ToolService):
                 filename = url.split('/')[-1]
                 if not filename:
                     filename = "downloaded_firmware.bin"
-                output_path = str(self.conf_dir / filename)
+                downloads_dir = self.user_dir / "firmware"
+                downloads_dir.mkdir(parents=True, exist_ok=True)
+                output_path = str(downloads_dir / filename)
             
             with open(output_path, 'wb') as f:
                 for chunk in response.iter_content(chunk_size=8192):
@@ -719,93 +877,103 @@ class FirmwareToolService(ToolService):
                 self.logger.error(f"Firmware not found: {name}")
                 return False
 
-            firmware_info = self.manifests[name]
-            device_type = firmware_info.get('device_type', '').lower()
-            firmware_path = firmware_info['path']
-
-            # Merge options from manifest and provided options
-            flash_options = firmware_info.get('flash_options', {}).copy()
-            if options:
-                flash_options.update(options)
-            
-            # Route to appropriate programmer based on device type
-            if device_type.startswith('esp32'):
-                if 'files' in flash_options:
-                    # Multi-file ESP32 flash
-                    result = self.esp32.flash_multi(
-                        port=flash_options.get('port', '/dev/ttyUSB0'),
-                        files=flash_options['files'],
-                        chip=flash_options.get('chip', 'esp32s3'),
-                        baud=flash_options.get('baud', '460800')
+            with self.resolve_firmware(name) as firmware_info:
+                device_type = firmware_info.get('device_type', '').lower()
+                firmware_path = firmware_info.get('path')
+
+                # Merge options from manifest and provided options
+                flash_options = dict(firmware_info.get('flash_options', {}))
+                if options:
+                    flash_options.update(options)
+
+                # Route to appropriate programmer based on device type
+                if device_type.startswith('esp32'):
+                    if 'files' in flash_options:
+                        # Multi-file ESP32 flash
+                        result = self.esp32.flash_multi(
+                            port=flash_options.get('port', '/dev/ttyUSB0'),
+                            files=flash_options['files'],
+                            chip=flash_options.get('chip', 'esp32s3'),
+                            baud=flash_options.get('baud', '460800')
+                        )
+                    else:
+                        # Single file ESP32 flash
+                        result = self.esp32.flash_single(
+                            port=flash_options.get('port', '/dev/ttyUSB0'),
+                            firmware_path=firmware_path,
+                            address=flash_options.get('address', '0x10000'),
+                            chip=flash_options.get('chip', 'esp32'),
+                            baud=flash_options.get('baud', '460800')
+                        )
+                    return result.success
+
+                elif device_type.startswith('stm32'):
+                    result = self.stm32.flash_firmware(
+                        firmware_path=firmware_path,
+                        interface=flash_options.get('interface', 'stlink'),
+                        target=flash_options.get('target', 'stm32f4x')
                     )
-                else:
-                    # Single file ESP32 flash
-                    result = self.esp32.flash_single(
-                        port=flash_options.get('port', '/dev/ttyUSB0'),
+                    return result.success
+
+                elif device_type == 'dfu':
+                    result = self.dfu.flash_firmware(
                         firmware_path=firmware_path,
-                        address=flash_options.get('address', '0x10000'),
-                        chip=flash_options.get('chip', 'esp32'),
-                        baud=flash_options.get('baud', '460800')
+                        vid=flash_options.get('vid'),
+                        pid=flash_options.get('pid'),
+                        alt=flash_options.get('alt')
                     )
-                return result.success
-            
-            elif device_type.startswith('stm32'):
-                result = self.stm32.flash_firmware(
-                    firmware_path=firmware_path,
-                    interface=flash_options.get('interface', 'stlink'),
-                    target=flash_options.get('target', 'stm32f4x')
-                )
-                return result.success
-            
-            elif device_type == 'dfu':
-                result = self.dfu.flash_firmware(
-                    firmware_path=firmware_path,
-                    vid=flash_options.get('vid'),
-                    pid=flash_options.get('pid'),
-                    alt=flash_options.get('alt')
-                )
-                return result.success
-            
-            elif device_type.startswith('fpga'):
-                target = flash_options.get('target', 'sram').lower()
-                if target == 'sram':
-                    result = self.fpga.load_sram(
-                        bitstream_path=firmware_path,
-                        board=flash_options.get('board'),
-                        cable=flash_options.get('cable')
+                    return result.success
+
+                elif device_type.startswith('fpga'):
+                    target = flash_options.get('target', 'sram').lower()
+                    if target == 'sram':
+                        result = self.fpga.load_sram(
+                            bitstream_path=firmware_path,
+                            board=flash_options.get('board'),
+                            cable=flash_options.get('cable')
+                        )
+                    else:
+                        result = self.fpga.flash_bitstream(
+                            bitstream_path=firmware_path,
+                            board=flash_options.get('board'),
+                            cable=flash_options.get('cable'),
+                            external_flash=flash_options.get('external_flash', False)
+                        )
+                    return result.success
+
+                elif device_type.startswith('greatfet'):
+                    result = self.greatfet.flash_firmware(
+                        firmware_path=firmware_path,
+                        target=flash_options.get('target', 'spi'),
+                        serial=flash_options.get('serial'),
+                        board=flash_options.get('board')
                     )
+                    return result.success
+
                 else:
-                    result = self.fpga.flash_bitstream(
-                        bitstream_path=firmware_path,
-                        board=flash_options.get('board'),
-                        cable=flash_options.get('cable'),
-                        external_flash=flash_options.get('external_flash', False)
-                    )
-                return result.success
-            
-            elif device_type.startswith('greatfet'):
-                result = self.greatfet.flash_firmware(
-                    firmware_path=firmware_path,
-                    target=flash_options.get('target', 'spi'),
-                    serial=flash_options.get('serial'),
-                    board=flash_options.get('board')
-                )
-                return result.success
-            
-            else:
-                self.logger.error(f"Unsupported device type: {device_type}")
-                return False
+                    self.logger.error(f"Unsupported device type: {device_type}")
+                    return False
 
         except Exception as e:
             self.logger.error(f"Error flashing firmware: {str(e)}")
             return False
     
     def _save_manifests(self):
-        """Save firmware manifests to JSON file"""
+        """Persist user-facing manifest entries to ``~/.iotsploit/firmware_manifest.json``.
+
+        Only entries that differ from the built-in manifest are written so
+        that the user override file stays minimal and keeps working even when
+        the bundled defaults change in a future iotsploit-drivers release.
+        """
         try:
-            import json
-            with open(self.manifest_file, 'w') as f:
-                json.dump(self.manifests, f, indent=2)
+            builtin = self._load_builtin_manifest()
+            user_entries = {
+                name: info
+                for name, info in self.manifests.items()
+                if builtin.get(name) != info
+            }
+            with open(self.user_manifest_file, 'w') as f:
+                json.dump(user_entries, f, indent=2)
         except Exception as e:
             self.logger.error(f"Error saving firmware manifest: {str(e)}")