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

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 {e}")
-        return "", ""
+        click.echo(f"Unable to retrieve board info with error: {e}, board may be still booting.")
+        return "", "", ""
 
 
 def _scp_file(sftp, local_path: str, remote_path: str):
@@ -95,7 +105,7 @@ def _scp_file(sftp, local_path: str, remote_path: str):
     sftp.put(local_path, remote_path)
     click.echo("✅ Upload complete")
 
-def _run_remote_command(ssh, command: str, password: str = DEFAULT_PASSWORD):
+def run_remote_command(ssh, command: str, password: str = DEFAULT_PASSWORD):
     """
     Run a remote command over SSH and stream its output live to the console.
     If the command starts with 'sudo', pipe in the password.
@@ -140,6 +150,13 @@ def _run_remote_command(ssh, command: str, password: str = DEFAULT_PASSWORD):
     for line in remaining_err.splitlines():
         click.echo(f"⚠️ {line}")
 
+def init_ssh_session(ip: str, password: str = DEFAULT_PASSWORD):
+    ssh = paramiko.SSHClient()
+    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+    ssh.connect(ip, username=DEFAULT_USER, password=password, timeout=10)
+    return ssh
+
 def reboot_remote_board(ip: str, passwd: str):
     """
     Reboot remote board by sending SSH command
@@ -150,13 +167,37 @@ def reboot_remote_board(ip: str, passwd: str):
 
         ssh.connect(ip, username=DEFAULT_USER, password=passwd, timeout=10)
 
-        _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 systemctl stop watchdog", password=passwd)
+        run_remote_command(ssh, "sudo bash -c 'echo b > /proc/sysrq-trigger'", password=passwd)
 
     except Exception as reboot_err:
         click.echo(f"⚠️  Unable to connect to the remote board")
 
-def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, passwd: str, reboot_and_wait: bool):
+
+def copy_file_to_remote_board(ip: str, file_path: str, remote_dir: str, passwd: str):
+    """
+    Copy a file to the remote board over SSH.
+    Assumes default credentials: sima / edgeai.
+    """
+    ssh = paramiko.SSHClient()
+    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+    try:
+        ssh.connect(ip, username=DEFAULT_USER, password=passwd, timeout=10)
+        sftp = ssh.open_sftp()
+
+        # Upload the file
+        base_file_path = os.path.basename(file_path)
+        click.echo(f"📤 Uploading {file_path} → {remote_dir}")
+        sftp.put(file_path, os.path.join(remote_dir, base_file_path))
+        return True
+
+    except Exception as e:
+        click.echo(f"❌ Remote file copy failed: {e}")
+
+    return False
+
+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.
@@ -169,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)
@@ -192,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
-        _run_remote_command(
+        _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:
@@ -206,11 +259,11 @@ 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...")
+                click.confirm("⚠️  Have you powercycled the board?", default=True, abort=True)
 
             try:
                 ssh.close()
@@ -229,7 +282,7 @@ def push_and_update_remote_board(ip: str, troot_path: str, palette_path: str, pa
                 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                 ssh.connect(ip, username=DEFAULT_USER, password=passwd, timeout=10)
 
-                _run_remote_command(ssh, "grep SIMA_BUILD_VERSION /etc/build 2>/dev/null || grep SIMA_BUILD_VERSION /etc/buildinfo 2>/dev/null", password=passwd)
+                run_remote_command(ssh, "grep SIMA_BUILD_VERSION /etc/build 2>/dev/null || grep SIMA_BUILD_VERSION /etc/buildinfo 2>/dev/null", password=passwd)
                 ssh.close()
             except Exception as e:
                 click.echo(f"❌ Unable to validate the version: {e}")

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,10 +151,21 @@ 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 = {
+            "Image",
+            "netboot.scr.uimg",
+            f"{board}-hhhl.dtb",
+            f"{board}-som.dtb",
+            f"{board}-dvt.dtb",
+            f"{board}-hhhl_x16.dtb",
+            f"simaai-image-{_flavor}-{board}.wic.gz",
+            f"simaai-image-{_flavor}-{board}.wic.bmap",
+            f"simaai-image-{_flavor}-{board}.cpio.gz"
         }
-
     extracted_paths = []
 
     try:
@@ -196,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.
 
@@ -204,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.
@@ -214,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()
@@ -236,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}")
@@ -298,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:
+        click.echo("⚠️  tRoot update skipped because the requested image doesn't contain troot image.")
 
-    if not troot_path or not palette_path:
+    if not palette_path:
         click.echo("❌ Required firmware files not found in extracted paths.")
         return
 
@@ -323,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.
 
@@ -334,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.")
@@ -361,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.
 
@@ -376,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.
 
@@ -402,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(
@@ -435,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/utils/net.py

@@ -0,0 +1,29 @@
+import psutil
+import socket
+
+def get_local_ip_candidates():
+    """
+    Return a list of IPv4 addresses on physical interfaces,
+    excluding VPN, loopback, and link-local interfaces.
+    """
+    vpn_prefixes = ("tun", "tap", "utun", "tailscale", "wg", "docker")  # WireGuard, Tailscale, etc.
+    ip_list = []
+
+    for iface_name, iface_addrs in psutil.net_if_addrs().items():
+        # Exclude VPN or tunnel interfaces
+        if iface_name.startswith(vpn_prefixes):
+            continue
+
+        for addr in iface_addrs:
+            if addr.family == socket.AF_INET:
+                ip = addr.address
+
+                # Skip loopback and link-local
+                if ip.startswith("127.") or ip.startswith("169.254."):
+                    continue
+
+                ip_list.append((iface_name, ip))
+
+    # Prioritize physical interfaces: eth0, en0, wlan0, etc.
+    ip_list.sort(key=lambda x: (not x[0].startswith(("eth", "en", "wlan", "wl")), x[0]))
+    return ip_list

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sima-cli
-Version: 0.0.19
+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
@@ -24,6 +24,8 @@ Requires-Dist: paramiko
 Requires-Dist: plotext
 Requires-Dist: rich
 Requires-Dist: InquirerPy
+Requires-Dist: tftpy
+Requires-Dist: psutil
 Dynamic: author
 Dynamic: license-file
 Dynamic: requires-python