sima-cli 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

sima_cli/{nvme → storage}/nvme.py

@@ -1,5 +1,7 @@
 import subprocess
 import click
+import re
+
 from sima_cli.utils.env import is_modalix_devkit
 
 def scan_nvme():
@@ -33,31 +35,68 @@ def format_nvme(lbaf_index):
 
 def add_nvme_to_fstab():
     """
-    Add /dev/nvme0n1p1 to /etc/fstab for persistent mounting at /mnt/nvme.
+    Add UUID-based entry for /dev/nvme0n1p1 to /etc/fstab for persistent mounting at /mnt/nvme.
     Only appends if the entry does not already exist.
-    Requires root permission to modify /etc/fstab.
+    Requires root permission to run blkid and modify /etc/fstab.
     """
+    device = "/dev/nvme0n1p1"
     fstab_path = "/etc/fstab"
-    nvme_entry = "/dev/nvme0n1p1  /mnt/nvme  ext4  defaults  0  2"
 
     try:
-        # Check if the entry already exists
+        # Get UUID and filesystem type using blkid
+        blkid_output = subprocess.check_output(["sudo", "blkid", device], text=True)
+        uuid_match = re.search(r'UUID="([^"]+)"', blkid_output)
+        type_match = re.search(r'TYPE="([^"]+)"', blkid_output)
+
+        if not uuid_match or not type_match:
+            click.echo("❌ Could not extract UUID or TYPE from blkid output.")
+            return
+
+        uuid = uuid_match.group(1)
+        fs_type = type_match.group(1)
+
+        # Construct the fstab line
+        fstab_entry = f"UUID={uuid}  /mnt/nvme  {fs_type}  defaults,noatime,noauto  0 0"
+
+        # Check if entry already exists
         with open(fstab_path, "r") as f:
             for line in f:
-                if "/dev/nvme0n1p1" in line or "/mnt/nvme" in line:
-                    click.echo("ℹ️  NVMe mount entry already exists in /etc/fstab.")
+                if uuid in line or "/mnt/nvme" in line:
+                    click.echo("ℹ️  NVMe UUID or mount point already exists in /etc/fstab.")
                     return
 
-        # Append the entry as sudo
-        append_cmd = f"echo '{nvme_entry}' | sudo tee -a {fstab_path} > /dev/null"
+        # Append the entry to fstab
+        append_cmd = f"echo '{fstab_entry}' | sudo tee -a {fstab_path} > /dev/null"
         subprocess.run(append_cmd, shell=True, check=True)
-        click.echo("✅ /etc/fstab updated to include NVMe auto-mount.")
+        click.echo(f"✅ Added NVMe UUID entry to /etc/fstab:\n{fstab_entry}")
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"❌ Failed to run blkid or append to fstab: {e}")
     except Exception as e:
-        click.echo(f"❌ Failed to update /etc/fstab: {e}")
+        click.echo(f"❌ Unexpected error: {e}")
 
 def mount_nvme():
-    subprocess.run("sudo mkdir -p /mnt/nvme", shell=True, check=True)
-    subprocess.run("sudo mount /dev/nvme0n1p1 /mnt/nvme", shell=True, check=True)
+    try:
+        # Create mount point
+        subprocess.run("sudo mkdir -p /mnt/nvme", shell=True, check=True)
+
+        # Mount the NVMe partition
+        subprocess.run("sudo mount /dev/nvme0n1p1 /mnt/nvme", shell=True, check=True)
+
+        add_nvme_to_fstab()
+
+        subprocess.run("sudo mount -a", shell=True, check=True)
+        
+        # Change ownership to user 'sima'
+        subprocess.run("sudo chown sima:sima /mnt/nvme", shell=True, check=True)
+
+        subprocess.run("sudo chmod 755 /mnt/nvme", shell=True, check=True)
+
+
+        print("✅ NVMe mounted and write permission granted to user 'sima'.")
+
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error during NVMe mount: {e}")
 
 def nvme_format():
     if not is_modalix_devkit():
@@ -87,8 +126,6 @@ def nvme_format():
         # Format and mount
         format_nvme(lbaf_index)
         mount_nvme()
-        add_nvme_to_fstab()
-
         click.echo("✅  NVMe drive formatted and mounted at /mnt/nvme.")
     except subprocess.CalledProcessError:
         click.echo("❌ Formatting process failed.")
@@ -100,13 +137,7 @@ def nvme_remount():
         return
 
     try:
-        # Ensure mount point exists
-        subprocess.run("sudo mkdir -p /mnt/nvme", shell=True, check=True)
-        # Mount the partition
-        subprocess.run("sudo mount /dev/nvme0n1p1 /mnt/nvme", shell=True, check=True)
-
-        # Add NVME to fstab
-        add_nvme_to_fstab()
+        mount_nvme()
 
     except subprocess.CalledProcessError as e:
         raise RuntimeError(f"Failed to remount NVMe: {e}")

sima_cli/storage/sdcard.py

@@ -0,0 +1,136 @@
+import click
+import subprocess
+import platform
+import shutil
+import sys
+import os
+import time
+
+from sima_cli.update.bootimg import list_removable_devices, unmount_device, _require_sudo
+from sima_cli.utils.env import is_sima_board
+
+def get_partition_path(device: str) -> str:
+    """For Linux: partition is device + '1'"""
+    return device + "1"
+
+
+def find_mkfs_ext4() -> str:
+    """Find mkfs.ext4 on Linux"""
+    mkfs_path = shutil.which("mkfs.ext4")
+    if mkfs_path and os.path.exists(mkfs_path):
+        return mkfs_path
+    return None
+
+
+def kill_partition_users(device_path: str):
+    """Kill processes using the partitions on the device"""
+    try:
+        output = subprocess.check_output(["lsblk", "-n", "-o", "NAME", device_path]).decode().strip().splitlines()
+        partitions = [f"/dev/{line.strip()}" for line in output if line.strip() and f"/dev/{line.strip()}" != device_path]
+        
+        for p in partitions:
+            try:
+                users = subprocess.check_output(["sudo", "lsof", p], stderr=subprocess.DEVNULL).decode().splitlines()
+                pids = {line.split()[1] for line in users[1:] if line.strip()}
+                for pid in pids:
+                    subprocess.run(["sudo", "kill", "-9", pid], check=False)
+            except subprocess.CalledProcessError:
+                # lsof exits 1 if no process is using the file
+                continue
+
+        # Let the system settle
+        time.sleep(1)
+
+    except Exception as e:
+        click.echo(f"⚠️ Could not resolve partition users: {e}")
+
+def create_partition_table(device_path: str):
+    """Linux: create a GPT partition table with one ext4 partition"""
+    click.echo(f"🧹 Wiping and partitioning {device_path} using parted (Linux)")
+    subprocess.run(["sudo", "parted", "-s", device_path, "mklabel", "gpt"], check=True)
+    subprocess.run(["sudo", "parted", "-s", device_path, "mkpart", "primary", "ext4", "0%", "100%"], check=True)
+    subprocess.run(["sudo", "partprobe", device_path], check=True)
+
+
+def force_release_device(device_path: str):
+    """
+    Try to forcefully release a device by killing users and removing mappings.
+    """
+    # Ensure partitions like /dev/sdc1 don't block parted
+    subprocess.run(["sudo", "umount", device_path + "1"], stderr=subprocess.DEVNULL)
+    subprocess.run(["sudo", "dmsetup", "remove", device_path], stderr=subprocess.DEVNULL)
+
+    # Try lsof to find open handles
+    try:
+        out = subprocess.check_output(["sudo", "lsof", device_path], stderr=subprocess.DEVNULL).decode()
+        for line in out.splitlines()[1:]:
+            pid = line.split()[1]
+            subprocess.run(["sudo", "kill", "-9", pid], check=False)
+    except subprocess.CalledProcessError:
+        # Likely no users
+        pass
+
+    # Final probe reset
+    subprocess.run(["sudo", "partprobe"], stderr=subprocess.DEVNULL)
+    subprocess.run(["sudo", "udevadm", "settle"], stderr=subprocess.DEVNULL)
+
+
+def sdcard_format():
+    """Linux-only SD card formatter for ext4."""
+
+    if platform.system() != "Linux":
+        click.echo("❌ This command only supports Desktop Linux.")
+        sys.exit(1)
+
+    if is_sima_board():
+        click.echo("❌ This command does not run on the DevKit due to lack of mkfs.ext4 support.")
+
+    mkfs_path = find_mkfs_ext4()
+    if not mkfs_path:
+        click.echo("❌ mkfs.ext4 not found on this platform.")
+        sys.exit(1)
+
+    devices = list_removable_devices()
+    if not devices:
+        click.echo("⚠️  No removable SD card found.")
+        return
+
+    click.echo("\n🔍 Detected removable devices:")
+    for i, d in enumerate(devices):
+        click.echo(f"[{i}] {d['path']} - {d['size']} - {d['name']}")
+
+    selected_path = None
+    if len(devices) == 1:
+        if click.confirm(f"\n✅ Use device {devices[0]['path']}?"):
+            selected_path = devices[0]['path']
+    else:
+        choice = click.prompt("Enter the number of the device to format", type=int)
+        if 0 <= choice < len(devices):
+            selected_path = devices[choice]['path']
+
+    if not selected_path:
+        click.echo("❌ No device selected. Operation cancelled.")
+        return
+
+    click.echo(f"\n🚨 WARNING: This will ERASE ALL DATA on {selected_path}")
+    if not click.confirm("Are you sure you want to continue?"):
+        click.echo("❌ Aborted by user.")
+        return
+
+    _require_sudo()
+    unmount_device(selected_path)
+    force_release_device(selected_path)
+    kill_partition_users(selected_path)
+
+    try:
+        create_partition_table(selected_path)
+        partition_path = get_partition_path(selected_path)
+
+        click.echo(f"🧱 Formatting partition {partition_path} as ext4 using {mkfs_path}")
+        subprocess.run(["sudo", mkfs_path, "-F", partition_path], check=True)
+
+        click.echo(f"✅ Successfully formatted {partition_path} as ext4, insert this SD card into MLSoC or Modalix Early Access Kit")
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"❌ Formatting failed: {e}")
+        sys.exit(1)

sima_cli/update/bootimg.py

@@ -306,7 +306,7 @@ def write_image(version: str, board: str, swtype: str, internal: bool = False, f
     Parameters:
         version (str): Firmware version to download (e.g., "1.6.0").
         board (str): Target board type, e.g., "modalix" or "mlsoc".
-        swtype (str): Software image type, e.g., "yocto" or "exlr".
+        swtype (str): Software image type, e.g., "yocto" or "elxr".
         internal (bool): Whether to use internal download sources. Defaults to False.
         flavor (str): Flavor of the software package - can be either headless or full.
 
@@ -318,17 +318,22 @@ def write_image(version: str, board: str, swtype: str, internal: bool = False, f
         file_list = download_image(version, board, swtype, internal, update_type='bootimg', flavor=flavor)
         if not isinstance(file_list, list):
             raise ValueError("Expected list of extracted files, got something else.")
+        
+        image_file = next(
+            (f for f in file_list if f.endswith(".wic") or f.endswith(".img")),
+            None
+        )
 
-        wic_file = next((f for f in file_list if f.endswith(".wic")), None)
-        if not wic_file:
-            raise FileNotFoundError("No .wic image file found after extraction.")
+        if not image_file:
+            raise FileNotFoundError("No .wic or .img image file found after extraction.")
 
     except Exception as e:
         raise RuntimeError(f"❌ Failed to download image: {e}")
 
     try:
-        click.echo(f"📝 Writing image to removable media: {wic_file}")
-        write_bootimg(wic_file)
+        click.echo(f"📝 Writing image to removable media: {image_file}")
+        write_bootimg(image_file)
+        
     except Exception as e:
         raise RuntimeError(f"❌ Failed to write image: {e}")
 

sima_cli/update/query.py

@@ -5,17 +5,32 @@ from sima_cli.utils.config import get_auth_token
 
 ARTIFACTORY_BASE_URL = artifactory_url() + '/artifactory'
 
-def _list_available_firmware_versions_internal(board: str, match_keyword: str = None, flavor: str = 'headless'):
-    fw_path = f"{board}" 
-    aql_query = f"""
-                items.find({{
-                    "repo": "soc-images",
-                    "path": {{
-                        "$match": "{fw_path}/*"
-                    }},
-                    "type": "folder"
-                }}).include("repo", "path", "name")
-                """.strip()
+def _list_available_firmware_versions_internal(board: str, match_keyword: str = None, flavor: str = 'headless', swtype: str = 'yocto'):
+    if swtype == 'yocto':
+        fw_path = f"{board}"
+        aql_query = f"""
+                    items.find({{
+                        "repo": "soc-images",
+                        "path": {{
+                            "$match": "{fw_path}/*"
+                        }},
+                        "type": "folder"
+                    }}).include("repo", "path", "name")
+                    """.strip()
+    elif swtype == 'elxr':
+        fw_path = f"elxr/{board}"
+        aql_query = f"""
+                    items.find({{
+                        "repo": "soc-images",
+                        "path": {{
+                            "$match": "{fw_path}/*/artifacts/palette"
+                        }},
+                        "name": "modalix-tftp-boot.tar.gz",
+                        "type": "file"
+                    }}).include("repo", "path", "name")
+                    """.strip()
+    else:
+        raise ValueError(f"Unsupported swtype: {swtype}")
 
     aql_url = f"{ARTIFACTORY_BASE_URL}/api/search/aql"
     headers = {
@@ -29,14 +44,18 @@ def _list_available_firmware_versions_internal(board: str, match_keyword: str =
 
     results = response.json().get("results", [])
 
-    # Reconstruct full paths and remove board prefix
-    full_paths = {
-        f"{item['path']}/{item['name']}".replace(fw_path + "/", "")
-        for item in results
-    }
-
-    # Extract top-level folders
-    top_level_folders = sorted({path.split("/")[0] for path in full_paths})
+    if swtype == 'yocto':
+        # Reconstruct full paths and remove board prefix
+        full_paths = {
+            f"{item['path']}/{item['name']}".replace(fw_path + "/", "")
+            for item in results
+        }
+        top_level_folders = sorted({path.split("/")[0] for path in full_paths})
+    else:  # elxr
+        # Extract version from path like: elxr/{board}/<version>/artifacts/palette
+        top_level_folders = sorted({
+            item['path'].split('/')[2] for item in results
+        })
 
     if match_keyword:
         match_keyword = match_keyword.lower()
@@ -46,7 +65,8 @@ def _list_available_firmware_versions_internal(board: str, match_keyword: str =
 
     return top_level_folders
 
-def _list_available_firmware_versions_external(board: str, match_keyword: str = None, flavor: str = 'headless'):
+
+def _list_available_firmware_versions_external(board: str, match_keyword: str = None, flavor: str = 'headless', swtype: str = 'yocto'):
     """
     Construct and return a list containing a single firmware download URL for a given board.
     
@@ -57,11 +77,11 @@ def _list_available_firmware_versions_external(board: str, match_keyword: str =
         board (str): The name of the hardware board.
         match_keyword (str, optional): A version string to match (e.g., '1.6' or '1.6.0').
         flavor (str, optional): A string indicating firmware flavor - headless or full.
+        swtype (str, optional): A string indicating firmware type - yocto or elxr.
 
     Returns:
         list[str]: A list containing one formatted firmware download URL.
     """
-    fwtype = 'yocto'
     cfg = load_resource_config()
     download_url_base = cfg.get('public').get('download').get('download_url')
 
@@ -69,14 +89,17 @@ def _list_available_firmware_versions_external(board: str, match_keyword: str =
         if re.fullmatch(r'\d+\.\d+', match_keyword):
             match_keyword += '.0'
 
+    # If it's headless then don't append flavor str to the URL, otherwise add it.
+    flavor_str = 'full-' if flavor == 'full' else ''
+
     firmware_download_url = (
-        f'{download_url_base}SDK{match_keyword}/devkit/{board}/{fwtype}/'
-        f'simaai-devkit-fw-{board}-{fwtype}-{match_keyword}.tar.gz'
+        f'{download_url_base}SDK{match_keyword}/devkit/{board}/{swtype}/'
+        f'simaai-devkit-fw-{board}-{swtype}-{flavor_str}{match_keyword}.tar.gz'
     )
     return [firmware_download_url]
 
 
-def list_available_firmware_versions(board: str, match_keyword: str = None, internal: bool = False, flavor: str = 'headless'):
+def list_available_firmware_versions(board: str, match_keyword: str = None, internal: bool = False, flavor: str = 'headless', swtype: str = 'yocto'):
     """
     Public interface to list available firmware versions.
 
@@ -90,6 +113,6 @@ def list_available_firmware_versions(board: str, match_keyword: str = None, inte
     - List[str] of firmware version folder names, or None if access is not allowed
     """
     if not internal:
-        return _list_available_firmware_versions_external(board, match_keyword, flavor)
+        return _list_available_firmware_versions_external(board, match_keyword, flavor, swtype)
 
-    return _list_available_firmware_versions_internal(board, match_keyword, flavor)
+    return _list_available_firmware_versions_internal(board, match_keyword, flavor, swtype)

sima_cli/update/remote.py

@@ -237,13 +237,8 @@ def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, pa
 
         # Run Palette update
         _flavor = 'palette' if flavor == 'headless' else 'graphics'
-        run_remote_command(
-            ssh,
-            f"sudo swupdate -H simaai-image-{_flavor}:1.0 -i /tmp/{palette_name}",
-            password=passwd
-        )
-        click.echo("✅ Board image update complete.")
 
+        # Set necessary env first to make sure it can access NVMe device
         if _flavor == 'graphics':
             click.echo(f"⚠️  With full image, setting U-Boot environment variable to support NVMe and GPU.")
             run_remote_command(
@@ -252,6 +247,13 @@ def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, pa
                 password=passwd
             )
 
+        run_remote_command(
+            ssh,
+            f"sudo swupdate -H simaai-image-{_flavor}:1.0 -i /tmp/{palette_name}",
+            password=passwd
+        )
+        click.echo("✅ Board image update complete.")
+
         # In the case of PCIe system, we don't need to reboot the card, instead, we will let it finish then update the PCIe driver in the host
         # After that we can reboot the whole system.
         if reboot_and_wait:

sima_cli/update/updater.py

@@ -29,7 +29,7 @@ else:
 def convert_flavor(flavor: str = 'headless'):
     return 'palette' if flavor == 'headless' else 'graphics'
 
-def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = False, flavor: str = 'headless') -> str:
+def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = False, flavor: str = 'headless', swtype: str = 'yocto') -> str:
     """
     Resolve the final firmware download URL based on board, version, and environment.
 
@@ -38,6 +38,7 @@ def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = Fals
         board (str): Board type ('davinci' or 'modalix').
         internal (bool): Whether to use internal config for URL construction.
         flavor (str): firmware image flavor, can be headless or full.
+        swtype (str): firmware image type, can be yocto or elxr
 
     Returns:
         str: Full download URL.
@@ -61,11 +62,16 @@ def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = Fals
     if board == 'davinci':
         flavor = 'headless'
 
-    image_file = 'release.tar.gz' if flavor == 'headless' else 'graphics.tar.gz'
-    download_url = url.rstrip("/") + f"/soc-images/{board}/{version_or_url}/artifacts/{image_file}"
+    if swtype == 'yocto':
+        image_file = 'release.tar.gz' if flavor == 'headless' else 'graphics.tar.gz'
+        download_url = url.rstrip("/") + f"/soc-images/{board}/{version_or_url}/artifacts/{image_file}"
+    elif swtype == 'elxr':
+        image_file = 'elxr-palette-modalix-1.7.0-arm64.img.gz' # temporary, this should change. 
+        download_url = url.rstrip("/") + f"/soc-images/elxr/{board}/{version_or_url}/artifacts/palette/{image_file}"
+
     return download_url
 
-def _pick_from_available_versions(board: str, version_or_url: str, internal: bool, flavor: str) -> str:
+def _pick_from_available_versions(board: str, version_or_url: str, internal: bool, flavor: str, swtype: str) -> str:
     """
     Presents an interactive menu (with search) for selecting a firmware version.
     """
@@ -73,7 +79,7 @@ def _pick_from_available_versions(board: str, version_or_url: str, internal: boo
     if "http" in version_or_url:
         return version_or_url
 
-    available_versions = list_available_firmware_versions(board, version_or_url, internal, flavor)
+    available_versions = list_available_firmware_versions(board, version_or_url, internal, flavor, swtype)
 
     try:
         if len(available_versions) > 1:
@@ -136,7 +142,7 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
 
     Returns:
         list: List of full paths to extracted files.
-    """
+    """    
     extract_dir = os.path.dirname(tar_path)
     _flavor = convert_flavor(flavor)
 
@@ -166,8 +172,28 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
             f"simaai-image-{_flavor}-{board}.wic.bmap",
             f"simaai-image-{_flavor}-{board}.cpio.gz"
         }
+
     extracted_paths = []
 
+    # Handle .img.gz downloaded directly (e.g., ELXR palette image)
+    if tar_path.endswith(".img.gz"):
+        extract_dir = os.path.dirname(tar_path)
+        uncompressed_path = tar_path[:-3]  # Remove .gz → .img
+
+        if os.path.exists(uncompressed_path):
+            click.echo(f"⚠️  Skipping decompression: {uncompressed_path} already exists")
+            return [tar_path, uncompressed_path]
+
+        try:
+            with gzip.open(tar_path, 'rb') as f_in:
+                with open(uncompressed_path, 'wb') as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+            click.echo(f"📦 Decompressed .img: {uncompressed_path}")
+            return [tar_path, uncompressed_path]
+        except Exception as e:
+            click.echo(f"❌ Failed to decompress {tar_path}: {e}")
+            return []
+
     try:
         try:
             tar = tarfile.open(tar_path, mode="r:gz")
@@ -177,7 +203,8 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
         with tar:
             for member in tar.getmembers():
                 base_name = os.path.basename(member.name)
-                if base_name in target_filenames:
+
+                if base_name in target_filenames or base_name.endswith(".img.gz"):
                     full_dest_path = os.path.join(extract_dir, member.name)
 
                     if os.path.exists(full_dest_path):
@@ -189,9 +216,9 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
                         click.echo(f"✅ Extracted: {full_dest_path}")
                         extracted_paths.append(full_dest_path)
 
-                    # If it's a .wic.gz file, decompress it now
+                    # Handle .wic.gz decompression
                     if full_dest_path.endswith(".wic.gz"):
-                        uncompressed_path = full_dest_path[:-3]  # remove .gz
+                        uncompressed_path = full_dest_path[:-3]
 
                         if os.path.exists(uncompressed_path):
                             click.echo(f"⚠️  Skipping decompression: {uncompressed_path} already exists")
@@ -216,8 +243,9 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
         click.echo(f"❌ Failed to extract files from archive: {e}")
         return []
 
+
     
-def _download_image(version_or_url: str, board: str, internal: bool = False, update_type: str = 'standard', flavor: str = 'headless'):
+def _download_image(version_or_url: str, board: str, internal: bool = False, update_type: str = 'standard', flavor: str = 'headless', swtype: str = 'yocto'):
     """
     Download or use a firmware image for the specified board and version or file path.
 
@@ -226,6 +254,7 @@ def _download_image(version_or_url: str, board: str, internal: bool = False, upd
         board (str): Target board type ('davinci' or 'modalix').
         internal (bool): Whether to use internal Artifactory resources.
         flavor (str): Flavor of the image, can be headless or full, supported for Modalix only.
+        swtype (str): Type of the image, can be yocto or elxr, supported for all H/W platforms. 
 
     Notes:
         - If a local file is provided, it skips downloading.
@@ -243,7 +272,7 @@ def _download_image(version_or_url: str, board: str, internal: bool = False, upd
             image_url = version_or_url
         else:
             # Case 3: Resolve standard version string (Artifactory/AWS)
-            image_url = _resolve_firmware_url(version_or_url, board, internal, flavor=flavor)
+            image_url = _resolve_firmware_url(version_or_url, board, internal, flavor=flavor, swtype=swtype)
 
         # Determine platform-safe temp directory
         temp_dir = tempfile.gettempdir()
@@ -414,9 +443,9 @@ def download_image(version_or_url: str, board: str, swtype: str, internal: bool
     """
     
     if 'http' not in version_or_url and not os.path.exists(version_or_url): 
-        version_or_url = _pick_from_available_versions(board, version_or_url, internal, flavor)
+        version_or_url = _pick_from_available_versions(board, version_or_url, internal, flavor, swtype)
 
-    extracted_paths = _download_image(version_or_url, board, internal, update_type, flavor=flavor) 
+    extracted_paths = _download_image(version_or_url, board, internal, update_type, flavor=flavor, swtype=swtype) 
     return extracted_paths
 
 def perform_update(version_or_url: str, ip: str = None, internal: bool = False, passwd: str = "edgeai", auto_confirm: bool = False, flavor: str = 'headless'):
@@ -448,7 +477,7 @@ def perform_update(version_or_url: str, ip: str = None, internal: bool = False,
             board, version, fdt_name = get_remote_board_info(ip, passwd)
 
         if board in ['davinci', 'modalix']:
-            click.echo(f"🔧 Target board: {board}, board currently running: {version}")
+            click.echo(f"🔧 Target board: {board} {fdt_name}, board currently running: {version}")
             
             if flavor == 'full' and fdt_name != 'modalix-som.dtb':
                 click.echo(f"❌ You've requested updating {fdt_name} to full image, this is only supported for the Modalix DevKit")

sima_cli/utils/disk.py

@@ -0,0 +1,15 @@
+import shutil
+
+def check_disk_space(required_bytes: int, folder: str = ".") -> bool:
+    """
+    Check if the given folder has enough free disk space.
+
+    Args:
+        required_bytes (int): Space required in bytes
+        folder (str): Path to check (default: current dir)
+
+    Returns:
+        bool: True if enough space is available, False otherwise
+    """
+    total, used, free = shutil.disk_usage(folder)
+    return free >= required_bytes

sima_cli/utils/env.py

@@ -92,6 +92,30 @@ def is_modalix_devkit() -> bool:
 
     return False
 
+def get_exact_devkit_type() -> str:
+    """
+    Extracts the exact devkit type from 'fdt_name' in fw_printenv output.
+
+    Returns:
+        str: The value of fdt_name (e.g., "modalix-som"), or an empty string if not found or unavailable.
+    """
+    if not shutil.which("fw_printenv"):
+        return ""
+
+    try:
+        output = subprocess.check_output(["fw_printenv"], text=True)
+        for line in output.splitlines():
+            line = line.strip()
+            if line.startswith("fdt_name="):
+                _, value = line.split("=", 1)
+                return value.strip().replace('.dtb','')
+    except subprocess.CalledProcessError:
+        return ""
+    except Exception:
+        return ""
+
+    return ""
+
 def is_palette_sdk() -> bool:
     """
     Check if the environment is running inside the Palette SDK container.

{sima_cli-0.0.21.dist-info → sima_cli-0.0.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sima-cli
-Version: 0.0.21
+Version: 0.0.23
 Summary: CLI tool for SiMa Developer Portal to download models, firmware, and apps.
 Home-page: https://developer.sima.ai/
 Author: SiMa.ai
@@ -26,6 +26,7 @@ Requires-Dist: rich
 Requires-Dist: InquirerPy
 Requires-Dist: tftpy
 Requires-Dist: psutil
+Requires-Dist: huggingface_hub
 Dynamic: author
 Dynamic: license-file
 Dynamic: requires-python