sima-cli 0.0.19__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.19"
+__version__ = "0.0.21"

sima_cli/cli.py

@@ -9,10 +9,13 @@ from sima_cli.__version__ import __version__
 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()
-@click.option('-i', '--internal', is_flag=True, help="Use internal Artifactory resources.")
+@click.option('-i', '--internal', is_flag=True, help="Use internal Artifactory resources, Authorized Sima employees only")
 @click.pass_context
 def main(ctx, internal):
     """
@@ -139,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.
@@ -152,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
@@ -225,29 +229,42 @@ 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("-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):
+def bootimg_cmd(ctx, version, boardtype, netboot, autoflash):
     """
-    Download and burn a bootable image onto removable media (e.g., SD card or USB stick).
+    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
     """
 
     from sima_cli.update.bootimg import write_image
+    from sima_cli.update.netboot import setup_netboot
 
     internal = ctx.obj.get("internal", False)
 
     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'
-        write_image(version, boardtype, 'yocto', internal)
+        if netboot or 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, flavor='headless')
+            click.echo("✅ Boot image successfully written.")
         click.echo("✅ Boot image successfully written.")
     except Exception as e:
         click.echo(f"❌ Failed to write boot image: {e}", err=True)
@@ -269,10 +286,10 @@ def install_cmd(ctx, component, version):
     Install supported components such as SDKs or tools.
 
     Examples:
-      cli install palette -v 1.6.0
-      cli install hostdriver -v 1.6.0
 
-      cli install optiview
+        sima-cli install hostdriver -v 1.6.0
+
+        sima-cli install optiview
     """
     component = component.lower()
     internal = ctx.obj.get("internal", False)
@@ -295,7 +312,78 @@ def install_cmd(ctx, component, version):
         install_optiview()
 
     click.echo("✅ Installation complete.")
+
+# ----------------------
+# Serial Subcommands
+# ----------------------
+@main.command(name="serial")
+@click.option("-b", "--baud", default=115200, show_default=True, help="Baud rate for the serial connection")
+@click.pass_context
+def serial_cmd(ctx, baud):
+    """
+    Connect to the UART serial console of the DevKit.
+
+    Automatically detects the serial port and launches a terminal emulator:
+
+    - macOS: uses 'picocom'
+    
+    - Linux: uses 'picocom'
     
+    - 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/install/optiview.py

@@ -1,9 +1,7 @@
 import sys
 import platform
 import click
-import urllib
 import json
-import tempfile
 import tarfile
 import os
 import subprocess
@@ -31,6 +29,12 @@ def install_optiview():
         version_url = f"{download_url_base}optiview/metadata.json"
         downloads_dir = Path.home() / "Downloads" / "optiview-installer"
         downloads_dir.mkdir(parents=True, exist_ok=True)
+
+        # Always redownload the metadata file to get the latest version
+        metadata_path = downloads_dir / "metadata.json"
+        if metadata_path.exists():
+            metadata_path.unlink()
+
         metadata_path = download_file_from_url(version_url, dest_folder=downloads_dir, internal=False)
 
         with open(metadata_path, "r") as f:
@@ -70,7 +74,8 @@ def install_optiview():
         else:
             subprocess.run(["bash", os.path.basename(script_path)], check=True, cwd=downloads_dir)
 
-        click.echo(f"✅ Optiview installed successfully. Run {downloads_dir}/run.sh to start optiview")
+        script_name = "run.bat" if platform.system() == "Windows" else "run.sh"
+        click.echo(f"✅ Optiview installed successfully. Run {downloads_dir}/{script_name} to start OptiView")
 
     except Exception as e:
         click.echo(f"❌ Installation failed: {e}")

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/serial/serial.py

@@ -0,0 +1,114 @@
+import platform
+import subprocess
+import shutil
+import click
+from sima_cli.utils.env import is_sima_board
+
+def connect_serial(ctx, baud):
+    """
+    Connect to the UART serial console of the DevKit.
+    Automatically installs required tools if missing.
+    """
+    if is_sima_board():
+        click.echo("🚫 This command is not supported on the DevKit. Please run it from your host machine.")
+        ctx.exit(1)
+
+    system = platform.system()
+    internal = ctx.obj.get("internal", False)
+
+    if system == "Darwin":
+        _connect_mac(baud)
+    elif system == "Linux":
+        _connect_linux(baud)
+    elif system == "Windows":
+        _print_windows_instructions()
+    else:
+        click.echo(f"⚠️ Unsupported OS: {system}. Only macOS, Linux, and Windows are supported.")
+        ctx.exit(1)
+
+    click.echo("✅ Serial session ended.")
+
+
+def _connect_mac(baud):
+    terminal = "picocom"
+    if not shutil.which(terminal):
+        click.echo("⚙️ 'picocom' is not installed. Attempting to install with Homebrew...")
+        if shutil.which("brew"):
+            subprocess.run(["brew", "install", "picocom"], check=True)
+        else:
+            click.echo("❌ Homebrew not found. Please install Homebrew first: https://brew.sh/")
+            raise SystemExit(1)
+
+    ports = sorted(
+        subprocess.getoutput("ls /dev/tty.usbserial-* /dev/cu.usbserial-* 2>/dev/null").splitlines()
+    )
+    if not ports:
+        click.echo("❌ No USB serial device found.")
+        raise SystemExit(1)
+
+    click.echo(f"Connecting to device with picocom ({baud} baud)...")
+    click.echo("🧷 To exit: Press Ctrl + A, then Ctrl + X")
+    click.echo("📜 Scrollback will work in your terminal as expected.\n")
+    
+    if not click.confirm("Proceed to connect?", default=True):
+        click.echo("❎ Connection aborted by user.")
+        return
+
+    port = ports[0]
+    click.echo(f"🔌 Connecting to {port} with picocom (115200 8N1)...")
+    try:
+        subprocess.run([
+            terminal,
+            "-b", f"{baud}",
+            "--databits", "8",
+            "--parity", "n",
+            "--stopbits", "1",
+            port
+        ])
+    except KeyboardInterrupt:
+        click.echo("\n❎ Serial connection interrupted by user.")
+
+
+def _connect_linux(baud):
+    terminal = "picocom"
+    if not shutil.which(terminal):
+        click.echo("⚙️ 'picocom' is not installed. Attempting to install via apt...")
+        if shutil.which("apt-get"):
+            subprocess.run(["sudo", "apt-get", "update"], check=True)
+            subprocess.run(["sudo", "apt-get", "install", "-y", "picocom"], check=True)
+        else:
+            click.echo("❌ 'apt-get' not found. Please install picocom manually.")
+            raise SystemExit(1)
+
+    ports = sorted(
+        subprocess.getoutput("ls /dev/ttyUSB* 2>/dev/null").splitlines()
+    )
+    if not ports:
+        click.echo("❌ No USB serial device found.")
+        raise SystemExit(1)
+
+    port = ports[0]
+    click.echo(f"🔌 Connecting to {port} with picocom ({baud} 8N1)...")
+    try:
+        subprocess.run(
+            ["sudo", terminal, "-b", f"{baud}", "--databits", "8", "--parity", "n", "--stopbits", "1", port]
+        )
+    except KeyboardInterrupt:
+        click.echo("\n❎ Serial connection interrupted by user.")
+
+
+def _print_windows_instructions():
+    click.echo("📘 To connect to the DevKit via a serial terminal on Windows, follow these steps:\n")
+
+    click.echo("1. Identify the COM Port:")
+    click.echo("   • Open **Device Manager** → Expand **Ports (COM & LPT)**.")
+    click.echo("   • Look for an entry like **USB Serial Port (COMx)**.\n")
+
+    click.echo("2. Install and Open a Serial Terminal:")
+    click.echo("   • Use **PuTTY** (Download from https://www.putty.org/) or **Tera Term**.")
+    click.echo("   • Set the **Connection Type** to **Serial**.")
+    click.echo("   • Enter the correct **COM Port** (e.g., COM3).")
+    click.echo("   • Set **Baud Rate** to **115200**.")
+    click.echo("   • Click **Open** to start the connection.\n")
+
+    click.echo("🔌 You are now ready to connect to the DevKit over serial.")