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

sima_cli/__version__.py

@@ -1,2 +1,2 @@
 # sima_cli/__version__.py
-__version__ = "0.0.20"
+__version__ = "0.0.21"

sima_cli/cli.py

@@ -10,6 +10,8 @@ from sima_cli.utils.config import CONFIG_PATH
 from sima_cli.install.optiview import install_optiview
 from sima_cli.install.hostdriver import install_hostdriver
 from sima_cli.serial.serial import connect_serial
+from sima_cli.nvme.nvme import nvme_format, nvme_remount
+from sima_cli.network.network import network_menu
 
 # Entry point for the CLI tool using Click's command group decorator
 @click.group()
@@ -140,12 +142,13 @@ def download(ctx, url, dest):
     help="Skip confirmation after firmware file is downloaded."
 )
 @click.option(
-    '--passwd',
+    '-p', '--passwd',
     default='edgeai',
     help="Optional SSH password for remote board (default is 'edgeai')."
 )
+@click.option("-f", "--flavor", type=click.Choice(["headless",  "full"], case_sensitive=False), default="headless", show_default=True, help="firmware flavor.")
 @click.pass_context
-def update(ctx, version_or_url, ip, yes, passwd):
+def update(ctx, version_or_url, ip, yes, passwd, flavor):
     """
     Run system update across different environments.
     Downloads and applies firmware updates for PCIe host or SiMa board.
@@ -153,7 +156,7 @@ def update(ctx, version_or_url, ip, yes, passwd):
     version_or_url: The version string (e.g. '1.5.0') or a direct URL to the firmware package.
     """
     internal = ctx.obj.get("internal", False)
-    perform_update(version_or_url, ip, internal, passwd=passwd, auto_confirm=yes)
+    perform_update(version_or_url, ip, internal, passwd=passwd, auto_confirm=yes, flavor=flavor)
 
 # ----------------------
 # Model Zoo Subcommands
@@ -226,18 +229,20 @@ def show_mla_memory_usage(ctx):
 # ----------------------
 @main.command(name="bootimg")
 @click.option("-v", "--version", required=True, help="Firmware version to download and write (e.g., 1.6.0)")
-@click.option("--boardtype", type=click.Choice(["modalix", "mlsoc"], case_sensitive=False), default="mlsoc", show_default=True, help="Target board type.")
-@click.option("--netboot", is_flag=True, default=False, show_default=True, help="Prepare image for network boot and launch TFTP server.")
-@click.option("--autoflash", is_flag=True, default=False, show_default=True, help="Net boot the DevKit and automatically flash the internal storage")
+@click.option("-b", "--boardtype", type=click.Choice(["modalix",  "mlsoc"], case_sensitive=False), default="mlsoc", show_default=True, help="Target board type.")
+@click.option("-n", "--netboot", is_flag=True, default=False, show_default=True, help="Prepare image for network boot and launch TFTP server.")
+@click.option("-a", "--autoflash", is_flag=True, default=False, show_default=True, help="Net boot the DevKit and automatically flash the internal storage - TBD")
 @click.pass_context
 def bootimg_cmd(ctx, version, boardtype, netboot, autoflash):
     """
     Download and burn a removable media or setup TFTP boot.
 
+    Only supports headless image
+    
     Examples:
       sima-cli bootimg -v 1.6.0
       sima-cli bootimg -v 1.6.0 --boardtype mlsoc
-      sima-cli bootimg -v 1.6.0 --boardtype modalix
+      sima-cli bootimg -v 1.6.0 --boardtype mlsoc
       sima-cli bootimg -v 1.6.0 --boardtype modalix --netboot
       sima-cli bootimg -v 1.6.0 --boardtype modalix --autoflash
     """
@@ -250,14 +255,15 @@ def bootimg_cmd(ctx, version, boardtype, netboot, autoflash):
     click.echo(f"📦 Preparing boot image:")
     click.echo(f"   🔹 Version   : {version}")
     click.echo(f"   🔹 Board Type: {boardtype}")
+    click.echo(f"   🔹 F/W Flavor: headless")
     
     try:
         boardtype = boardtype if boardtype != 'mlsoc' else 'davinci'
         if netboot or autoflash:
-            setup_netboot(version, boardtype, internal, autoflash)
+            setup_netboot(version, boardtype, internal, autoflash, flavor='headless')
             click.echo("✅ Netboot image prepared and TFTP server is running.")
         else:
-            write_image(version, boardtype, 'yocto', internal)
+            write_image(version, boardtype, 'yocto', internal, flavor='headless')
             click.echo("✅ Boot image successfully written.")
         click.echo("✅ Boot image successfully written.")
     except Exception as e:
@@ -326,6 +332,59 @@ def serial_cmd(ctx, baud):
     - Windows: shows PuTTY/Tera Term setup instructions
     """
     connect_serial(ctx, baud)
+
+# ----------------------
+# Network Subcommands
+# ----------------------
+@main.command(name="network")
+@click.pass_context
+def network_cmd(ctx):
+    """
+    Setup Network IP address on the DevKit
+
+    This command only works on the DevKit. It allows user to switch between DHCP and Static (Default addresses) IP.
+
+    """
+    network_menu()
+
+# ----------------------
+# NVME Subcommands
+# ----------------------
+NVME_OPERATIONS = {"format", "remount"}
+@main.command(name="nvme")
+@click.argument("operation", type=click.Choice(NVME_OPERATIONS, case_sensitive=False))
+@click.pass_context
+def nvme_cmd(ctx, operation):
+    """
+    Perform NVMe operations on the Modalix DevKit.
+
+    Available operations:
+
+      format   - Format the NVMe drive and mount it to /mnt/nvme
+
+      remount  - Remount the existing NVMe partition to /mnt/nvme
+
+    Example:
+      sima-cli nvme format
+
+      sima-cli nvme remount
+    """
+    operation = operation.lower()
+
+    if operation == "format":
+        nvme_format()
+
+    elif operation == "remount":
+        try:
+            nvme_remount()
+            click.echo("✅ NVMe drive successfully remounted at /mnt/nvme.")
+        except Exception as e:
+            click.echo(f"❌ Failed to remount NVMe drive: {e}")
+
+    else:
+        click.echo(f"❌ Unsupported NVMe operation: {operation}")
+        ctx.exit(1)
+
 # ----------------------
 # App Zoo Subcommands
 # ----------------------

sima_cli/network/network.py

@@ -0,0 +1,193 @@
+from InquirerPy import inquirer
+import subprocess
+import os
+import re
+import time
+from sima_cli.utils.env import is_sima_board
+
+IP_CMD = "/sbin/ip"
+
+def extract_interface_index(name):
+    """Extract numeric index from interface name for sorting (e.g., end0 → 0)."""
+    match = re.search(r'(\d+)$', name)
+    return int(match.group(1)) if match else float('inf')
+
+def get_interfaces():
+    interfaces = []
+    ip_output = subprocess.check_output([IP_CMD, '-o', 'link', 'show']).decode()
+    for line in ip_output.splitlines():
+        match = re.match(r'\d+: (\w+):', line)
+        if match:
+            iface = match.group(1)
+            if iface.startswith('lo'):
+                continue
+            try:
+                with open(f"/sys/class/net/{iface}/carrier") as f:
+                    carrier = f.read().strip() == "1"
+            except FileNotFoundError:
+                carrier = False
+
+            try:
+                ip_addr = subprocess.check_output([IP_CMD, '-4', 'addr', 'show', iface]).decode()
+                ip_match = re.search(r'inet (\d+\.\d+\.\d+\.\d+)', ip_addr)
+                ip = ip_match.group(1) if ip_match else "IP Not Assigned"
+            except subprocess.CalledProcessError:
+                ip = "IP Not Assigned"
+
+            # Check internet connectivity only if carrier is up
+            internet = False
+            if carrier:
+                try:
+                    result = subprocess.run(
+                        ["ping", "-I", iface, "-c", "1", "-W", "1", "8.8.8.8"],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL
+                    )
+                    internet = result.returncode == 0
+                except Exception:
+                    internet = False
+
+            interfaces.append({
+                "name": iface,
+                "carrier": carrier,
+                "ip": ip,
+                "internet": internet
+            })
+
+    interfaces.sort(key=lambda x: extract_interface_index(x["name"]))
+    return interfaces
+
+def move_network_file(iface, mode):
+    try:
+        networkd_dir = "/etc/systemd/network"
+        files = os.listdir(networkd_dir)
+
+        # Match any static file for this iface
+        pattern = re.compile(r"(\d+)-(%s)-static\.network" % re.escape(iface))
+        static_file = next((f for f in files if pattern.match(f)), None)
+        if not static_file:
+            print(f"⚠️ No static .network file found for {iface}")
+            return
+
+        src = os.path.join(networkd_dir, static_file)
+        desired_prefix = "02" if mode == "static" else "20"
+        dst_file = f"{desired_prefix}-{iface}-static.network"
+        dst = os.path.join(networkd_dir, dst_file)
+
+        if static_file == dst_file:
+            print(f"✅ Interface {iface} is already set to {mode.upper()}. No changes made.")
+        else:
+            print(f"🔧 Changing mode of {iface} to {mode.upper()}...")
+            subprocess.run(["sudo", "mv", src, dst], check=True)
+
+        # Modify content only if going to static
+        if mode == "static":
+            # Read as normal user
+            with open(dst, "r") as f:
+                lines = f.readlines()
+            cleaned = [line for line in lines if "KernelCommandLine=!netcfg=dhcp" not in line]
+
+            # Only write if change is needed
+            if len(cleaned) != len(lines):
+                temp_path = f"/tmp/{iface}-static.network"
+                with open(temp_path, "w") as tmpf:
+                    tmpf.writelines(cleaned)
+                subprocess.run(["sudo", "cp", temp_path, dst], check=True)
+                os.remove(temp_path)
+                print(f"✂️ Removed KernelCommandLine override from {dst_file}")
+            else:
+                print(f"✅ No KernelCommandLine override found — file already clean.")
+
+        # Restart networkd
+        subprocess.run(["sudo", "systemctl", "restart", "systemd-networkd"])
+        time.sleep(2)
+    except Exception as e:
+        print(f"❌ Unable to change configuration, error: {e}")
+
+def get_gateway_for_interface(ip):
+    """Guess the gateway from the IP address, assuming .1 is the router."""
+    if ip == "IP Not Assigned":
+        return None
+    parts = ip.split('.')
+    parts[-1] = "1"
+    return ".".join(parts)
+
+def set_default_route(iface, ip):
+    gateway = get_gateway_for_interface(ip)
+    if not gateway:
+        print(f"❌ Cannot set default route — IP not assigned for {iface}")
+        return
+
+    print(f"🔧 Setting default route via {iface} ({gateway})")
+
+    try:
+        # Delete all existing default routes
+        subprocess.run(["sudo", "/sbin/ip", "route", "del", "default"], check=False)
+
+        # Add new default route for this iface
+        subprocess.run(
+            ["sudo", "/sbin/ip", "route", "add", "default", "via", gateway, "dev", iface],
+            check=True
+        )
+        print(f"✅ Default route set via {iface} ({gateway})")
+    except subprocess.CalledProcessError:
+        print(f"❌ Failed to set default route via {iface}")
+
+def network_menu():
+    if not is_sima_board():
+        print("❌ This command only runs on the DevKit")
+        return
+
+    while True:
+        interfaces = get_interfaces()
+        choices = ["🚪 Quit Menu"]
+        iface_map = {}
+
+        for iface in interfaces:
+            status_icon = "carrier (✅)" if iface["carrier"] else "carrier (❌)"
+            internet_icon = "internet (🌐)" if iface.get("internet") else "internet (🚫)"
+            label = f"{iface['name']:<10} {status_icon} {internet_icon}  {iface['ip']:<20}"
+            choices.append(label)
+            iface_map[label] = iface
+
+        try:
+            iface_choice = inquirer.fuzzy(
+                message="Select Ethernet Interface:",
+                choices=choices,
+                instruction="(Type or use ↑↓)",
+            ).execute()
+        except KeyboardInterrupt:
+            print("\nExiting.")
+            break
+
+        if iface_choice is None or iface_choice == "🚪 Quit Menu":
+            print("Exiting.")
+            break
+
+        selected_iface = iface_map[iface_choice]
+
+        try:
+            second = inquirer.select(
+                message=f"Configure {selected_iface['name']}:",
+                choices=[
+                    "Set to DHCP",
+                    "Set to Default Static IP",
+                    "Set as Default Route",
+                    "Back to Interface Selection"
+                ]
+            ).execute()
+        except KeyboardInterrupt:
+            print("\nExiting.")
+            break
+
+        if second == "Set to DHCP":
+            move_network_file(selected_iface["name"], "dhcp")
+        elif second == "Set to Default Static IP":
+            move_network_file(selected_iface["name"], "static")
+        elif second == "Set as Default Route":
+            set_default_route(selected_iface["name"], selected_iface["ip"])            
+        else:
+            continue 
+
+if __name__ == '__main__':
+    network_menu()

sima_cli/nvme/nvme.py

@@ -0,0 +1,112 @@
+import subprocess
+import click
+from sima_cli.utils.env import is_modalix_devkit
+
+def scan_nvme():
+    try:
+        nvme_list = subprocess.check_output("sudo nvme list", shell=True, text=True).strip()
+        if "/dev/nvme0n1" in nvme_list:
+            return nvme_list
+    except subprocess.CalledProcessError:
+        pass
+    return None
+
+def get_lba_format_index():
+    try:
+        lba_output = subprocess.check_output("sudo nvme id-ns -H /dev/nvme0n1 | grep 'Relative Performance'", shell=True, text=True)
+        lbaf_line = lba_output.strip().split(":")[0]
+        lbaf_index = lbaf_line.split()[-1]
+        return lbaf_index
+    except Exception:
+        return None
+
+def format_nvme(lbaf_index):
+    cmds = [
+        f"sudo nvme format /dev/nvme0n1 --lbaf={lbaf_index}",
+        "sudo parted -a optimal /dev/nvme0n1 mklabel gpt",
+        "sudo parted -a optimal /dev/nvme0n1 mkpart primary ext4 0% 100%",
+        "sudo mkfs.ext4 /dev/nvme0n1p1",
+        "sudo nvme smart-log -H /dev/nvme0n1"
+    ]
+    for cmd in cmds:
+        subprocess.run(cmd, shell=True, check=True)
+
+def add_nvme_to_fstab():
+    """
+    Add /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.
+    """
+    fstab_path = "/etc/fstab"
+    nvme_entry = "/dev/nvme0n1p1  /mnt/nvme  ext4  defaults  0  2"
+
+    try:
+        # Check if the 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.")
+                    return
+
+        # Append the entry as sudo
+        append_cmd = f"echo '{nvme_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.")
+    except Exception as e:
+        click.echo(f"❌ Failed to update /etc/fstab: {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)
+
+def nvme_format():
+    if not is_modalix_devkit():
+        click.echo("❌  This command can only be run on the Modalix DevKit.")
+        return
+
+    nvme_info = scan_nvme()
+    if not nvme_info:
+        click.echo("❌  No NVMe drive detected.")
+        return
+    click.echo(nvme_info)
+
+    lbaf_index = get_lba_format_index()
+    if lbaf_index is None:
+        click.echo("❌  Failed to detect LBA format index.")
+        return
+    click.echo(f"ℹ️  Detected LBA format index: {lbaf_index}")
+
+    if not click.confirm("⚠️  Are you sure you want to format /dev/nvme0n1? This will erase all data."):
+        click.echo("❌ Aborted by user.")
+        return
+
+    try:
+        # Unmount before formatting, ignore error if not mounted
+        subprocess.run("sudo umount /mnt/nvme", shell=True, check=False)
+
+        # 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.")
+
+
+def nvme_remount():
+    if not is_modalix_devkit():
+        click.echo("❌ This command can only be run on the Modalix DevKit.")
+        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()
+
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to remount NVMe: {e}")

sima_cli/update/bootimg.py

@@ -5,8 +5,8 @@ import sys
 import os
 import select
 import re
-import threading
-from tftpy import TftpServer
+
+from sima_cli.update.updater import download_image
 
 try:
     from tqdm import tqdm
@@ -299,7 +299,7 @@ def write_bootimg(image_path):
         click.echo("ℹ️  Please manually eject the device.")
 
 
-def write_image(version: str, board: str, swtype: str, internal: bool = False):
+def write_image(version: str, board: str, swtype: str, internal: bool = False, flavor: str = 'headless'):
     """
     Download and write a bootable firmware image to a removable storage device.
 
@@ -308,13 +308,14 @@ def write_image(version: str, board: str, swtype: str, internal: bool = False):
         board (str): Target board type, e.g., "modalix" or "mlsoc".
         swtype (str): Software image type, e.g., "yocto" or "exlr".
         internal (bool): Whether to use internal download sources. Defaults to False.
+        flavor (str): Flavor of the software package - can be either headless or full.
 
     Raises:
         RuntimeError: If the download or write process fails.
     """
     try:
         click.echo(f"⬇️  Downloading boot image for version: {version}, board: {board}, swtype: {swtype}")
-        file_list = download_image(version, board, swtype, internal, update_type='bootimg')
+        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.")
 

sima_cli/update/local.py

@@ -73,7 +73,7 @@ def get_local_board_info() -> Tuple[str, str]:
     return board_type, build_version
 
 
-def push_and_update_local_board(troot_path: str, palette_path: str, passwd: str):
+def push_and_update_local_board(troot_path: str, palette_path: str, passwd: str, flavor: str):
     """
     Perform local firmware update using swupdate commands.
     Calls swupdate directly on the provided file paths.
@@ -82,15 +82,17 @@ def push_and_update_local_board(troot_path: str, palette_path: str, passwd: str)
 
     try:
         # Run tRoot update
-        click.echo("⚙️  Flashing tRoot image...")
-        if not _run_local_cmd(f"sudo swupdate -H simaai-image-troot:1.0 -i {troot_path}", passwd):
-            click.echo("❌ tRoot update failed.")
-            return
-        click.echo("✅ tRoot update completed.")
-
+        if troot_path != None:
+            click.echo("⚙️  Flashing tRoot image...")
+            if not _run_local_cmd(f"sudo swupdate -H simaai-image-troot:1.0 -i {troot_path}", passwd):
+                click.echo("❌ tRoot update failed.")
+                return
+            click.echo("✅ tRoot update completed.")
+            
         # Run Palette update
         click.echo("⚙️  Flashing System image...")
-        if not _run_local_cmd(f"sudo swupdate -H simaai-image-palette:1.0 -i {palette_path}", passwd):
+        _flavor = 'palette' if flavor == 'headless' else 'graphics'
+        if not _run_local_cmd(f"sudo swupdate -H simaai-image-{_flavor}:1.0 -i {palette_path}", passwd):
             click.echo("❌ System image update failed.")
             return
         click.echo("✅ System image update completed. Please powercycle the device")

sima_cli/update/netboot.py

@@ -127,7 +127,7 @@ class ClientManager:
 
             while not self.shutdown_event.is_set():
                 try:
-                    board_type, build_version = get_remote_board_info(ip)
+                    board_type, build_version, _ = get_remote_board_info(ip)
 
                     if board_type and build_version:
                         with self.lock:
@@ -346,7 +346,7 @@ def run_cli(client_manager):
             click.echo("\n🛑 Exiting netboot session.")
             return True
 
-def setup_netboot(version: str, board: str, internal: bool = False, autoflash: bool = False):
+def setup_netboot(version: str, board: str, internal: bool = False, autoflash: bool = False, flavor: str = 'headless'):
     """
     Download and serve a bootable image for network boot over TFTP with client monitoring.
 
@@ -355,6 +355,7 @@ def setup_netboot(version: str, board: str, internal: bool = False, autoflash: b
         board (str): Target board type, e.g., "modalix" or "davinci".
         internal (bool): Whether to use internal download sources. Defaults to False.
         autoflash (bool): Whether to automatically flash the devkit when networked booted. Defaults to False.
+        flavor (str): The software flavor, can be either headless or full.
 
     Raises:
         RuntimeError: If the download or TFTP setup fails.
@@ -367,7 +368,7 @@ def setup_netboot(version: str, board: str, internal: bool = False, autoflash: b
 
     try:
         click.echo(f"⬇️ Downloading netboot image for version: {version}, board: {board}")
-        file_list = download_image(version, board, swtype="yocto", internal=internal, update_type='netboot')
+        file_list = download_image(version, board, swtype="yocto", internal=internal, update_type='netboot', flavor=flavor)
         if not isinstance(file_list, list):
             raise ValueError("Expected list of extracted files, got something else.")
         extract_dir = os.path.dirname(file_list[0])

sima_cli/update/query.py

@@ -5,7 +5,7 @@ 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):
+def _list_available_firmware_versions_internal(board: str, match_keyword: str = None, flavor: str = 'headless'):
     fw_path = f"{board}" 
     aql_query = f"""
                 items.find({{
@@ -46,7 +46,7 @@ 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):
+def _list_available_firmware_versions_external(board: str, match_keyword: str = None, flavor: str = 'headless'):
     """
     Construct and return a list containing a single firmware download URL for a given board.
     
@@ -56,6 +56,7 @@ def _list_available_firmware_versions_external(board: str, match_keyword: str =
     Args:
         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.
 
     Returns:
         list[str]: A list containing one formatted firmware download URL.
@@ -75,7 +76,7 @@ def _list_available_firmware_versions_external(board: str, match_keyword: str =
     return [firmware_download_url]
 
 
-def list_available_firmware_versions(board: str, match_keyword: str = None, internal: bool = False):
+def list_available_firmware_versions(board: str, match_keyword: str = None, internal: bool = False, flavor: str = 'headless'):
     """
     Public interface to list available firmware versions.
 
@@ -83,11 +84,12 @@ def list_available_firmware_versions(board: str, match_keyword: str = None, inte
     - board: str – Name of the board (e.g. 'davinci')
     - match_keyword: str – Optional keyword to filter versions (case-insensitive)
     - internal: bool – Must be True to access internal Artifactory
+    - flavor (str, optional): A string indicating firmware flavor - headless or full.
 
     Returns:
     - 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)
+        return _list_available_firmware_versions_external(board, match_keyword, flavor)
 
-    return _list_available_firmware_versions_internal(board, match_keyword)
+    return _list_available_firmware_versions_internal(board, match_keyword, flavor)

sima_cli/update/remote.py

@@ -51,41 +51,51 @@ def _wait_for_ssh(ip: str, timeout: int = 120):
     else:
         print("\r✅ Board is online!           \n")
 
-def get_remote_board_info(ip: str, passwd: str = DEFAULT_PASSWORD) -> Tuple[str, str]:
+def get_remote_board_info(ip: str, passwd: str = DEFAULT_PASSWORD) -> Tuple[str, str, str]:
     """
-    Connect to the remote board and retrieve board type and build version.
+    Connect to the remote board and retrieve board type, build version, and fdt_name.
 
     Args:
         ip (str): IP address of the board.
 
     Returns:
-        (board_type, build_version): Tuple of strings, or ('', '') on failure.
+        (board_type, build_version, fdt_name): Tuple of strings, or ('', '', '') on failure.
     """
     board_type = ""
     build_version = ""
+    fdt_name = ""
 
     try:
         ssh = paramiko.SSHClient()
         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         ssh.connect(ip, username=DEFAULT_USER, password=passwd, timeout=10)
 
-        # Try /etc/build first then /etc/buildinfo
+        # Retrieve build info
         stdin, stdout, stderr = ssh.exec_command("cat /etc/build 2>/dev/null || cat /etc/buildinfo 2>/dev/null")
-        output = stdout.read().decode()
+        build_output = stdout.read().decode()
+
+        # Retrieve fdt_name from fw_printenv
+        stdin, stdout, stderr = ssh.exec_command("fw_printenv fdt_name 2>/dev/null")
+        fdt_output = stdout.read().decode()
+
         ssh.close()
 
-        for line in output.splitlines():
+        for line in build_output.splitlines():
             line = line.strip()
             if line.startswith("MACHINE"):
                 board_type = line.split("=", 1)[-1].strip()
             elif line.startswith("SIMA_BUILD_VERSION"):
                 build_version = line.split("=", 1)[-1].strip()
 
-        return board_type, build_version
+        for line in fdt_output.splitlines():
+            if line.startswith("fdt_name"):
+                fdt_name = line.split("=", 1)[-1].strip()
+
+        return board_type, build_version, fdt_name
 
     except Exception as e:
         click.echo(f"Unable to retrieve board info with error: {e}, board may be still booting.")
-        return "", ""
+        return "", "", ""
 
 
 def _scp_file(sftp, local_path: str, remote_path: str):
@@ -187,7 +197,7 @@ def copy_file_to_remote_board(ip: str, file_path: str, remote_dir: str, passwd:
 
     return False
 
-def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, passwd: str, reboot_and_wait: bool):
+def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, passwd: str, reboot_and_wait: bool, flavor: str = 'headless'):
     """
     Upload and install firmware images to remote board over SSH.
     Assumes default credentials: sima / edgeai.
@@ -200,21 +210,24 @@ def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, pa
         ssh.connect(ip, username=DEFAULT_USER, password=passwd, timeout=10)
         sftp = ssh.open_sftp()
         remote_dir = "/tmp"
-
-        # Upload tRoot image
-        troot_name = os.path.basename(troot_path)
         palette_name = os.path.basename(palette_path)
-        _scp_file(sftp, troot_path, os.path.join(remote_dir, troot_name))
-        click.echo("🚀 Uploaded tRoot image.")
 
-        # Run tRoot update
-        run_remote_command(
-            ssh,
-            f"sudo swupdate -H simaai-image-troot:1.0 -i /tmp/{troot_name}", password=passwd
-        )
-        click.echo("✅ tRoot update complete, the board needs to be rebooted to proceed to the next phase of update.")
-        click.confirm("⚠️  Have you rebooted the board?", default=True, abort=True)
-        _wait_for_ssh(ip, timeout=120)
+        # Upload tRoot image
+        if troot_path is not None:
+            troot_name = os.path.basename(troot_path)
+            _scp_file(sftp, troot_path, os.path.join(remote_dir, troot_name))
+            click.echo("🚀 Uploaded tRoot image.")
+
+            # Run tRoot update
+            run_remote_command(
+                ssh,
+                f"sudo swupdate -H simaai-image-troot:1.0 -i /tmp/{troot_name}", password=passwd
+            )
+            click.echo("✅ tRoot update complete, the board needs to be rebooted to proceed to the next phase of update.")
+            click.confirm("⚠️  Have you rebooted the board?", default=True, abort=True)
+            _wait_for_ssh(ip, timeout=120)
+        else:
+            click.echo("⚠️  tRoot update skipped because the requested image doesn't contain troot image.")
 
         # Upload Palette image
         ssh.connect(ip, username=DEFAULT_USER, password=passwd, timeout=10)
@@ -223,13 +236,22 @@ def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, pa
         click.echo("🚀 Uploaded system image.")
 
         # Run Palette update
+        _flavor = 'palette' if flavor == 'headless' else 'graphics'
         run_remote_command(
             ssh,
-            f"sudo swupdate -H simaai-image-palette:1.0 -i /tmp/{palette_name}",
+            f"sudo swupdate -H simaai-image-{_flavor}:1.0 -i /tmp/{palette_name}",
             password=passwd
         )
         click.echo("✅ Board image update complete.")
 
+        if _flavor == 'graphics':
+            click.echo(f"⚠️  With full image, setting U-Boot environment variable to support NVMe and GPU.")
+            run_remote_command(
+                ssh,
+                f"sudo fw_setenv dtbos pcie-4rc-2rc-2rc.dtbo",
+                password=passwd
+            )
+
         # 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:
@@ -237,8 +259,7 @@ def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, pa
             click.echo("🔁 Rebooting board after update. Waiting for reconnection...")
 
             try:
-                run_remote_command(ssh, "sudo systemctl stop watchdog", password=passwd)
-                run_remote_command(ssh, "sudo bash -c 'echo b > /proc/sysrq-trigger'", password=passwd)
+                run_remote_command(ssh, "sudo reboot", password=passwd)
 
             except Exception as reboot_err:
                 click.echo(f"⚠️  SSH connection lost due to reboot (expected): {reboot_err}, please powercycle the board...")

sima_cli/update/updater.py

@@ -26,7 +26,10 @@ else:
     push_and_update_local_board = None
 
 
-def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = False) -> str:
+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:
     """
     Resolve the final firmware download URL based on board, version, and environment.
 
@@ -34,6 +37,7 @@ def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = Fals
         version_or_url (str): Either a version string (e.g. 1.6.0_master_B1611) or a full URL.
         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.
 
     Returns:
         str: Full download URL.
@@ -53,11 +57,15 @@ def _resolve_firmware_url(version_or_url: str, board: str, internal: bool = Fals
     if not url:
         raise RuntimeError("⚠️ 'url' is not defined in resource config.")
 
-    # Format full download path, internal for now.
-    download_url = url.rstrip("/") + f"/soc-images/{board}/{version_or_url}/artifacts/release.tar.gz"
+    # Davinci only supports headless images
+    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}"
     return download_url
 
-def _pick_from_available_versions(board: str, version_or_url: str, internal: bool) -> str:
+def _pick_from_available_versions(board: str, version_or_url: str, internal: bool, flavor: str) -> str:
     """
     Presents an interactive menu (with search) for selecting a firmware version.
     """
@@ -65,7 +73,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)
+    available_versions = list_available_firmware_versions(board, version_or_url, internal, flavor)
 
     try:
         if len(available_versions) > 1:
@@ -113,7 +121,7 @@ def _sanitize_url_to_filename(url: str) -> str:
     return safe_name
 
 
-def _extract_required_files(tar_path: str, board: str, update_type: str = 'standard') -> list:
+def _extract_required_files(tar_path: str, board: str, update_type: str = 'standard', flavor: str = 'headless') -> list:
     """
     Extract required files from a .tar.gz or .tar archive into the same folder
     and return the full paths to the extracted files (with subfolder if present).
@@ -124,15 +132,17 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
         tar_path (str): Path to the downloaded or provided firmware archive.
         board (str): Board type ('davinci' or 'modalix').
         update_type (str): Update type ('standard' or 'bootimg').
+        flavor (str): flavor of the firmware ('full' or 'headless').
 
     Returns:
         list: List of full paths to extracted files.
     """
     extract_dir = os.path.dirname(tar_path)
+    _flavor = convert_flavor(flavor)
 
     target_filenames = {
         "troot-upgrade-simaai-ev.swu",
-        f"simaai-image-palette-upgrade-{board}.swu"
+        f"simaai-image-{_flavor}-upgrade-{board}.swu"
     }
 
     env_type, _os = get_environment_type()
@@ -141,8 +151,8 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
 
     if update_type == 'bootimg':
         target_filenames = {
-            f"simaai-image-palette-{board}.wic.gz",
-            f"simaai-image-palette-{board}.wic.bmap"
+            f"simaai-image-{_flavor}-{board}.wic.gz",
+            f"simaai-image-{_flavor}-{board}.wic.bmap"
         }
     elif update_type == 'netboot':
         target_filenames = {
@@ -152,9 +162,9 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
             f"{board}-som.dtb",
             f"{board}-dvt.dtb",
             f"{board}-hhhl_x16.dtb",
-            f"simaai-image-palette-{board}.wic.gz",
-            f"simaai-image-palette-{board}.wic.bmap",
-            f"simaai-image-palette-{board}.cpio.gz"
+            f"simaai-image-{_flavor}-{board}.wic.gz",
+            f"simaai-image-{_flavor}-{board}.wic.bmap",
+            f"simaai-image-{_flavor}-{board}.cpio.gz"
         }
     extracted_paths = []
 
@@ -207,7 +217,7 @@ def _extract_required_files(tar_path: str, board: str, update_type: str = 'stand
         return []
 
     
-def _download_image(version_or_url: str, board: str, internal: bool = False, update_type: str = 'standard'):
+def _download_image(version_or_url: str, board: str, internal: bool = False, update_type: str = 'standard', flavor: str = 'headless'):
     """
     Download or use a firmware image for the specified board and version or file path.
 
@@ -215,6 +225,7 @@ def _download_image(version_or_url: str, board: str, internal: bool = False, upd
         version_or_url (str): Version string, HTTP(S) URL, or local file path.
         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.
 
     Notes:
         - If a local file is provided, it skips downloading.
@@ -225,14 +236,14 @@ def _download_image(version_or_url: str, board: str, internal: bool = False, upd
         # Case 1: Local file provided
         if os.path.exists(version_or_url) and os.path.isfile(version_or_url):
             click.echo(f"📁 Using local firmware file: {version_or_url}")
-            return _extract_required_files(version_or_url, board, update_type)
+            return _extract_required_files(version_or_url, board, update_type, flavor)
 
         # Case 2: Treat as custom full URL
         if version_or_url.startswith("http://") or version_or_url.startswith("https://"):
             image_url = version_or_url
         else:
             # Case 3: Resolve standard version string (Artifactory/AWS)
-            image_url = _resolve_firmware_url(version_or_url, board, internal)
+            image_url = _resolve_firmware_url(version_or_url, board, internal, flavor=flavor)
 
         # Determine platform-safe temp directory
         temp_dir = tempfile.gettempdir()
@@ -247,7 +258,7 @@ def _download_image(version_or_url: str, board: str, internal: bool = False, upd
         firmware_path = download_file_from_url(image_url, dest_path, internal=internal)
 
         click.echo(f"📦 Firmware downloaded to: {firmware_path}")
-        return _extract_required_files(firmware_path, board, update_type)
+        return _extract_required_files(firmware_path, board, update_type, flavor)
 
     except Exception as e:
         click.echo(f"❌ Host update failed: {e}")
@@ -309,21 +320,26 @@ def _update_sdk(version_or_url: str, board: str):
     click.echo(f"⚙️  Simulated SDK firmware update logic for board '{board}' (not implemented).")
     # TODO: Implement update via SDK-based communication or tools
 
-def _update_board(extracted_paths: List[str], board: str, passwd: str):
+def _update_board(extracted_paths: List[str], board: str, passwd: str, flavor: str):
     """
     Perform local firmware update using extracted files.
 
     Args:
         extracted_paths (List[str]): Paths to the extracted .swu files.
         board (str): Board type expected (e.g. 'davinci', 'modalix').
+        flavor (str): headless or full.
     """
     click.echo(f"⚙️  Starting local firmware update for board '{board}'...")
 
     # Locate the needed files
+    _flavor = 'palette' if flavor == 'headless' else 'graphics'
     troot_path = next((p for p in extracted_paths if "troot-upgrade" in os.path.basename(p)), None)
-    palette_path = next((p for p in extracted_paths if f"palette-upgrade-{board}" in os.path.basename(p)), None)
+    palette_path = next((p for p in extracted_paths if f"{_flavor}-upgrade-{board}" in os.path.basename(p)), None)
 
-    if not troot_path or not palette_path:
+    if not troot_path:
+        click.echo("⚠️  tRoot update skipped because the requested image doesn't contain troot image.")
+
+    if not palette_path:
         click.echo("❌ Required firmware files not found in extracted paths.")
         return
 
@@ -334,9 +350,9 @@ def _update_board(extracted_paths: List[str], board: str, passwd: str):
         return
 
     click.echo("✅ Board verified. Starting update...")
-    push_and_update_local_board(troot_path, palette_path, passwd)
+    push_and_update_local_board(troot_path, palette_path, passwd, flavor)
 
-def _update_remote(extracted_paths: List[str], ip: str, board: str, passwd: str, reboot_and_wait: bool = True):
+def _update_remote(extracted_paths: List[str], ip: str, board: str, passwd: str, reboot_and_wait: bool = True, flavor: str = 'headless'):
     """
     Perform remote firmware update to the specified board via SSH.
 
@@ -345,21 +361,25 @@ def _update_remote(extracted_paths: List[str], ip: str, board: str, passwd: str,
         ip (str): IP of the remote board.
         board (str): Expected board type ('davinci' or 'modalix').
         passwd (str): password to access the board, if it's not default
+        flavor (str): flavor of the firmware - headless or full
     """
     click.echo(f"⚙️  Starting remote update on '{ip}' for board type '{board}'...")
 
     # Locate files
+    _flavor = convert_flavor(flavor)
     troot_path = next((p for p in extracted_paths if "troot-upgrade" in os.path.basename(p)), None)
-    palette_path = next((p for p in extracted_paths if f"palette-upgrade-{board}" in os.path.basename(p)), None)
+    palette_path = next((p for p in extracted_paths if f"{_flavor}-upgrade-{board}" in os.path.basename(p)), None)
     script_path = next((p for p in extracted_paths if p.endswith("sima_pcie_host_pkg.sh")), None)
 
-    if not troot_path or not palette_path:
-        click.echo("❌ Required firmware files not found in extracted paths.")
+    if not troot_path:
+        click.echo("⚠️  Required troot firmware files not found in extracted paths, skipping tRoot update...")
+    if not palette_path:
+        click.echo("❌ Required o/s files not found in extracted paths.")
         return
 
     # Get remote board info
     click.echo("🔍 Checking remote board type and version...")
-    remote_board, remote_version = get_remote_board_info(ip, passwd)
+    remote_board, remote_version, fdt_name = get_remote_board_info(ip, passwd)
 
     if not remote_board:
         click.echo("❌ Could not determine remote board type.")
@@ -372,12 +392,12 @@ def _update_remote(extracted_paths: List[str], ip: str, board: str, passwd: str,
         return
 
     # Proceed with update
-    click.echo("✅ Board type verified. Proceeding with firmware update...")
-    push_and_update_remote_board(ip, troot_path, palette_path, passwd=passwd, reboot_and_wait=reboot_and_wait)
+    click.echo(f"✅ Board type verified. Proceeding with firmware update: troot : {troot_path}, os: {palette_path}...")
+    push_and_update_remote_board(ip, troot_path, palette_path, passwd=passwd, reboot_and_wait=reboot_and_wait, flavor=flavor)
 
     return script_path
 
-def download_image(version_or_url: str, board: str, swtype: str, internal: bool = False, update_type: str = 'standard'):
+def download_image(version_or_url: str, board: str, swtype: str, internal: bool = False, update_type: str = 'standard', flavor: str = 'headless'):
     """
     Download and extract a firmware image for a specified board.
 
@@ -387,18 +407,19 @@ def download_image(version_or_url: str, board: str, swtype: str, internal: bool
         swtype (str): The software type (default to 'davinci', possible values: `davinci`, `modalix`): not supported for now
         internal (bool): Whether to use internal download paths (e.g., Artifactory).
         update_type (str): Whether this is standard update or writing boot image.
+        flavor (str): Flavor of the image, can be headless or full.
 
     Returns:
         List[str]: Paths to the extracted image files.
     """
     
     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)
+        version_or_url = _pick_from_available_versions(board, version_or_url, internal, flavor)
 
-    extracted_paths = _download_image(version_or_url, board, internal, update_type) 
+    extracted_paths = _download_image(version_or_url, board, internal, update_type, flavor=flavor) 
     return extracted_paths
 
-def perform_update(version_or_url: str, ip: str = None, internal: bool = False, passwd: str = "edgeai", auto_confirm: bool = False):
+def perform_update(version_or_url: str, ip: str = None, internal: bool = False, passwd: str = "edgeai", auto_confirm: bool = False, flavor: str = 'headless'):
     r"""
     Update the system based on environment and input.
 
@@ -413,25 +434,35 @@ def perform_update(version_or_url: str, ip: str = None, internal: bool = False,
         internal (bool): If True, enable internal-only behaviors (e.g., Artifactory access).
         passwd (str): Password for the board user (default: "edgeai").
         auto_confirm (bool): If True, auto-confirm firmware update without prompting.
+        flavor (str): headless or full
     """
     try:
         board = ''
         env_type, env_subtype = get_environment_type()
         click.echo(f"🔄 Running update for environment: {env_type} ({env_subtype})")
-        click.echo(f"🔧 Requested version or URL: {version_or_url}")
+        click.echo(f"🔧 Requested version or URL: {version_or_url}, with flavor {flavor}")
 
         if env_type == 'board':
             board, version = get_local_board_info()
         else:
-            board, version = get_remote_board_info(ip, passwd)
+            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}")
-                        
+            
+            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")
+                return
+
+            # Davinci only supports headless build, so ignore the full flavor
+            if board == 'davinci' and flavor != 'headless':
+                click.echo(f"MLSoC only supports headless image, ignoring {flavor} setting")
+                flavor = 'headless'
+            
             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)
+                version_or_url = _pick_from_available_versions(board, version_or_url, internal, flavor=flavor)
 
-            extracted_paths = _download_image(version_or_url, board, internal)
+            extracted_paths = _download_image(version_or_url, board, internal, flavor=flavor)
 
             if not auto_confirm:
                 click.confirm(
@@ -446,15 +477,15 @@ def perform_update(version_or_url: str, ip: str = None, internal: bool = False,
                     # Always update the remote device first then update the host driver, otherwise the host would 
                     # not be able to connect to the board
                     click.echo("👉 Updating PCIe host driver and downloading firmware...")        
-                    script_path = _update_remote(extracted_paths, ip, board, passwd, reboot_and_wait=False)
+                    script_path = _update_remote(extracted_paths, ip, board, passwd, reboot_and_wait=False, flavor=flavor)
                     _update_host(script_path, board, ip, passwd)
                 elif env_type == "board":
-                    _update_board(extracted_paths, board, passwd)
+                    _update_board(extracted_paths, board, passwd, flavor=flavor)
                 elif env_type == "sdk":
                     click.echo("👉 Updating firmware from within the Palette SDK...: Not implemented yet")
                 elif ip:
                     click.echo(f"👉 Updating firmware on remote board at {ip}...")
-                    _update_remote(extracted_paths, ip, board, passwd, reboot_and_wait=True)
+                    _update_remote(extracted_paths, ip, board, passwd, reboot_and_wait=True, flavor=flavor)
                 else:
                     click.echo("❌ Unknown environment. Use --ip to specify target device.")
         else:

sima_cli/utils/env.py

@@ -1,6 +1,7 @@
 import os
 import subprocess
 import platform
+import shutil
 from typing import Tuple
 
 # Utility functions to determine the environment:
@@ -70,6 +71,27 @@ def get_sima_board_type() -> str:
 
     return ""
 
+def is_modalix_devkit() -> bool:
+    """
+    Determines whether the current system is a Modalix DevKit (SOM)
+    by checking if 'fdt_name=modalix-som.dtb' is present in fw_printenv output.
+
+    Returns:
+        bool: True if running on a Modalix DevKit, False otherwise.
+    """
+    if not shutil.which("fw_printenv"):
+        return False
+
+    try:
+        output = subprocess.check_output(["fw_printenv"], text=True)
+        for line in output.splitlines():
+            if line.strip().startswith("fdt_name="):
+                return "modalix-som.dtb" in line
+    except subprocess.CalledProcessError:
+        return False
+
+    return False
+
 def is_palette_sdk() -> bool:
     """
     Check if the environment is running inside the Palette SDK container.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sima-cli
-Version: 0.0.20
+Version: 0.0.21
 Summary: CLI tool for SiMa Developer Portal to download models, firmware, and apps.
 Home-page: https://developer.sima.ai/
 Author: SiMa.ai

{sima_cli-0.0.20.dist-info → sima_cli-0.0.21.dist-info}/RECORD

@@ -1,7 +1,7 @@
 sima_cli/__init__.py,sha256=Nb2jSg9-CX1XvSc1c21U9qQ3atINxphuNkNfmR-9P3o,332
 sima_cli/__main__.py,sha256=ehzD6AZ7zGytC2gLSvaJatxeD0jJdaEvNJvwYeGsWOg,69
-sima_cli/__version__.py,sha256=U-M6HF-1PsXkez7yhqMRRsr6FObzLVRQ6Spmo4bkl30,49
-sima_cli/cli.py,sha256=b4ScjEa5Ltikry4ftZdJaNxBlSMYtmjYlodqzbRyWRk,12658
+sima_cli/__version__.py,sha256=5C0RJVUsHkVkCFWA58oGCy10CpKRe_uE6H3nKgYCdRk,49
+sima_cli/cli.py,sha256=OwoMg0UFl4Qy4FTCj5fXSNg-BjhC91dPYeZRSr15gBs,14447
 sima_cli/app_zoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/app_zoo/app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -18,26 +18,28 @@ sima_cli/install/palette.py,sha256=uRznoHa4Mv9ZXHp6AoqknfC3RxpYNKi9Ins756Cyifk,3
 sima_cli/mla/meminfo.py,sha256=ndc8kQJmWGEIdvNh6iIhATGdrkqM2pbddr_eHxaPNfg,1466
 sima_cli/model_zoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/model_zoo/model.py,sha256=q91Nrg62j1TqwPO8HiX4nlEFCCmzNEFcyFTBVMbJm8w,9836
+sima_cli/network/network.py,sha256=C4vCBPT-n1SNdBDAhzFCawBhny0Y9g9yB2u2LlXVSG4,7012
+sima_cli/nvme/nvme.py,sha256=ABLdRm83y2x-UX-rk8W7Uh2nvOnHYc6xECwLitRHcUc,3856
 sima_cli/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/sdk/syscheck.py,sha256=h9zCULW67y4i2hqiGc-hc1ucBDShA5FAe9NxwBGq-fM,4575
 sima_cli/serial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/serial/serial.py,sha256=6xRta_PzE_DmmooYq35lbK76TYpAny5SEJAdYC_3fH0,4141
 sima_cli/update/__init__.py,sha256=0P-z-rSaev40IhfJXytK3AFWv2_sdQU4Ry6ei2sEus0,66
 sima_cli/update/bmaptool.py,sha256=KrhUGShBwY4Wzz50QiuMYAxxPgEy1nz5C68G-0a4qF4,4988
-sima_cli/update/bootimg.py,sha256=AOZI9bXrY8x-1gwlbIINdOUNO_naw9qteNJqeQ9_o-Y,13407
-sima_cli/update/local.py,sha256=CyUFLs5Lz5w4VyM6ip4wndKBBLz3_KZ-3scEvSiOrcg,3299
-sima_cli/update/netboot.py,sha256=xTtRf8LMuqC_Ye-m6tlv5kbwkZwexc623kRymwiLTf4,18528
-sima_cli/update/query.py,sha256=cVkUMLZkONJ2XMEwqEC-JqLVB38hOqfWM2hB2ehBK6Y,3272
-sima_cli/update/remote.py,sha256=RXQbNCDr7d8wLJ7pdGwA6G3gzgwrfZ9l_7YNYUfGHDU,10067
-sima_cli/update/updater.py,sha256=1K87YDj_isuMtL38ZI-hwBTIRmk3WqbkE6s-J0IVp-Q,18884
+sima_cli/update/bootimg.py,sha256=jsxMv7OlrDP_fjzfTMn5UoiSOv7afB2LSM0pR50b4uE,13541
+sima_cli/update/local.py,sha256=Blje7O2pcBopBLXwuVI826lnjPMTJ3lPU85dTUWUV48,3445
+sima_cli/update/netboot.py,sha256=RqFgBhixcjPEwdVGvKhR0TeztoFnmGigmXlA71WVksA,18647
+sima_cli/update/query.py,sha256=9yCW1ZQl42DAWV_7sbNsqEKeS9FzHdvgXpY5eS2GpDs,3540
+sima_cli/update/remote.py,sha256=uv0cezLeG4tsJvalgm_VDOo3EUCU7LB3nXl8mNFFtds,10934
+sima_cli/update/updater.py,sha256=gW6kIX0Xn16FWmaRryfu0BmM25bIaphCQ6tWu9N4tVY,20868
 sima_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/utils/artifactory.py,sha256=6YyVpzVm8ATy7NEwT9nkWx-wptkXrvG7Wl_zDT6jmLs,2390
 sima_cli/utils/config.py,sha256=wE-cPQqY_gOqaP8t01xsRHD9tBUGk9MgBUm2GYYxI3E,1616
 sima_cli/utils/config_loader.py,sha256=7I5we1yiCai18j9R9jvhfUzAmT3OjAqVK35XSLuUw8c,2005
-sima_cli/utils/env.py,sha256=Jrb062EnpMBr1jGMotBlI2j9LEH6W1Z5Tgt6LHY7yYQ,5753
+sima_cli/utils/env.py,sha256=m6yRnNuajYWTfysPJLk6vJY9Z1kYGFIAaArnpHXhino,6411
 sima_cli/utils/net.py,sha256=WVntA4CqipkNrrkA4tBVRadJft_pMcGYh4Re5xk3rqo,971
 sima_cli/utils/network.py,sha256=UvqxbqbWUczGFyO-t1SybG7Q-x9kjUVRNIn_D6APzy8,1252
-sima_cli-0.0.20.dist-info/licenses/LICENSE,sha256=a260OFuV4SsMZ6sQCkoYbtws_4o2deFtbnT9kg7Rfd4,1082
+sima_cli-0.0.21.dist-info/licenses/LICENSE,sha256=a260OFuV4SsMZ6sQCkoYbtws_4o2deFtbnT9kg7Rfd4,1082
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_app_zoo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_auth.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -46,8 +48,8 @@ tests/test_download.py,sha256=t87DwxlHs26_ws9rpcHGwr_OrcRPd3hz6Zmm0vRee2U,4465
 tests/test_firmware.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_model_zoo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sima_cli-0.0.20.dist-info/METADATA,sha256=0KwVrHOfciP7OQWLcpOhnarYPVPkTcffT4QSKNXqzwo,3674
-sima_cli-0.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sima_cli-0.0.20.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
-sima_cli-0.0.20.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
-sima_cli-0.0.20.dist-info/RECORD,,
+sima_cli-0.0.21.dist-info/METADATA,sha256=vX4CMPMiH5QqByXV6CphuCM2rh1vwefsLRCctFcmP9o,3674
+sima_cli-0.0.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sima_cli-0.0.21.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
+sima_cli-0.0.21.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
+sima_cli-0.0.21.dist-info/RECORD,,