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

sima_cli/__version__.py

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

sima_cli/cli.py

@@ -9,6 +9,7 @@ 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.install.metadata_installer import install_from_metadata, metadata_resolver
 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
@@ -118,6 +119,7 @@ def download(ctx, url, dest):
         click.echo(f"\n✅ File downloaded successfully to: {path}")
         return
     except Exception as e:
+        click.echo(f"❌ Failed to download as file {e}")
         pass
 
     # If that fails, try to treat as a folder and download all files
@@ -278,22 +280,44 @@ SDK_INDEPENDENT_COMPONENTS = {"optiview"}
 ALL_COMPONENTS = SDK_DEPENDENT_COMPONENTS | SDK_INDEPENDENT_COMPONENTS
 
 @main.command(name="install")
-@click.argument("component", type=click.Choice(ALL_COMPONENTS, case_sensitive=False))
-@click.option("-v", "--version", help="SDK version (required for SDK-dependent components)")
+@click.argument("component", required=False)
+@click.option("-v", "--version", help="SDK version (required for SDK-dependent components unless --metadata is provided)")
+@click.option("-m", "--mirror", help="URL to a metadata.json file for generic installation")
+@click.option("-t", "--tag", help="Tag of the package (optional)")
 @click.pass_context
-def install_cmd(ctx, component, version):
+def install_cmd(ctx, component, version, mirror, tag):
     """
-    Install supported components such as SDKs or tools.
+    Install supported components such as SDKs, tools, or generic packages via metadata.
 
     Examples:
 
         sima-cli install hostdriver -v 1.6.0
 
         sima-cli install optiview
+
+        sima-cli install -m https://example.com/packages/foo/metadata.json
+
+        sima-cli install examples.llima -v 1.7.0
     """
-    component = component.lower()
     internal = ctx.obj.get("internal", False)
 
+    # Metadata-based installation path
+    if mirror:
+        if component:
+            click.echo(f"⚠️ Component '{component}' is ignored when using --metadata. Proceeding with metadata-based installation.")
+        click.echo(f"🔧 Installing generic component from metadata URL: {mirror}")
+        if install_from_metadata(metadata_url=mirror, internal=internal):
+            click.echo("✅ Installation complete.")
+        return
+
+    # No component and no metadata: error
+    if not component:
+        click.echo("❌ You must specify either a component name or provide --metadata.")
+        ctx.exit(1)
+
+    component = component.lower()
+
+    # Validate version requirement
     if component in SDK_DEPENDENT_COMPONENTS and not version:
         click.echo(f"❌ The component '{component}' requires a specific SDK version. Please provide one using -v.")
         ctx.exit(1)
@@ -301,7 +325,7 @@ def install_cmd(ctx, component, version):
     if component in SDK_INDEPENDENT_COMPONENTS and version:
         click.echo(f"ℹ️ The component '{component}' does not require an SDK version. Ignoring -v {version}.")
 
-    # Perform the installation logic
+    # Hardcoded component installation
     if component == "palette":
         click.echo(f"🔧 Installing SDK component 'palette' for version {version} is not implemented yet...")
     elif component == "hostdriver":
@@ -310,9 +334,20 @@ def install_cmd(ctx, component, version):
     elif component == "optiview":
         click.echo("🔧 Installing tool 'optiview'...")
         install_optiview()
+    else:
+        # Case 4: Try to resolve metadata URL from version + tag
+        try:
+            metadata_url = metadata_resolver(component, version, tag)
+            click.echo(f"🔧 Installing '{component}' from resolved metadata: {metadata_url}")
+            if install_from_metadata(metadata_url=metadata_url, internal=internal):
+                click.echo("✅ Installation complete.")
+        except Exception as e:
+            click.echo(f"❌ Failed to resolve metadata for component '{component}': {e}")
+            ctx.exit(1)
 
     click.echo("✅ Installation complete.")
 
+
 # ----------------------
 # Serial Subcommands
 # ----------------------
@@ -377,9 +412,9 @@ def nvme_cmd(ctx, operation):
     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}")
+            ctx.exit(1)
 
     else:
         click.echo(f"❌ Unsupported NVMe operation: {operation}")

sima_cli/download/downloader.py

@@ -80,10 +80,14 @@ def download_file_from_url(url: str, dest_folder: str = ".", internal: bool = Fa
                 headers["Authorization"] = f"Bearer {auth_token}"
             request_fn = requests.get
             head_fn = requests.head
-        else:
+        elif 'https://docs.sima.ai' in url:
             session = login_external()
             request_fn = session.get
             head_fn = session.head
+        else:
+            session = requests.Session()
+            request_fn = session.get
+            head_fn = session.head            
 
         # HEAD request to get total file size
         head = head_fn(url, headers=headers, timeout=10)
@@ -95,7 +99,7 @@ def download_file_from_url(url: str, dest_folder: str = ".", internal: bool = Fa
             existing_size = os.path.getsize(dest_path)
 
             if existing_size == total_size:
-                print(f"✔ File already exists and is complete: {file_name}")
+                print(f"✔  File already exists and is complete: {file_name}")
                 return dest_path
             elif existing_size < total_size:
                 resume_header['Range'] = f'bytes={existing_size}-'
@@ -113,7 +117,7 @@ def download_file_from_url(url: str, dest_folder: str = ".", internal: bool = Fa
             final_total = existing_size + content_length
 
             with open(dest_path, mode) as f, tqdm(
-                desc=f"Downloading {file_name}",
+                desc=f"⬇️  Downloading {file_name}",
                 total=final_total,
                 initial=existing_size,
                 unit='B',

sima_cli/install/metadata_info.py

@@ -0,0 +1,57 @@
+from rich import print
+from rich.table import Table
+from rich.panel import Panel
+
+def print_metadata_summary(metadata: dict):
+    table = Table(show_header=False, box=None, padding=(0, 1))
+
+    table.add_row("[bold]Name[/bold]", metadata.get("name", "N/A"))
+    table.add_row("[bold]Version[/bold]", metadata.get("version", "N/A"))
+    table.add_row("[bold]Release[/bold]", metadata.get("release", "N/A"))
+    table.add_row("[bold]Description[/bold]", metadata.get("description", "N/A"))
+
+    # Platform info
+    platform_info = []
+    for p in metadata.get("platforms", []):
+        platform_type = p.get("type", "unknown")
+        if platform_type == "board":
+            compat = ", ".join(p.get("compatible_with", []))
+            platform_info.append(f"{platform_type} ({compat})")
+        elif platform_type in ("host", "generic"):
+            os_list = ", ".join(p.get("os", []))
+            platform_info.append(f"{platform_type} ({os_list})")
+        else:
+            platform_info.append(platform_type)
+
+    table.add_row("[bold]Platforms[/bold]", "; ".join(platform_info) or "N/A")
+
+    # Resources
+    resource_count = len(metadata.get("resources", []))
+    table.add_row("[bold]Resources[/bold]", f"{resource_count} file(s)")
+
+    # Size
+    size = metadata.get("size", {})
+    table.add_row("[bold]Download Size[/bold]", size.get("download", "N/A"))
+    table.add_row("[bold]Install Size[/bold]", size.get("install", "N/A"))
+
+    print()
+    print(Panel(table, title="📦 Package Summary", expand=False))
+    print()
+
+
+def parse_size_string_to_bytes(size_str: str) -> int:
+    """
+    Convert a size string like '40GB' or '512MB' to bytes.
+    """
+    size_str = size_str.strip().upper()
+    units = {"KB": 10**3, "MB": 10**6, "GB": 10**9}
+
+    for unit, multiplier in units.items():
+        if size_str.endswith(unit):
+            try:
+                value = float(size_str[:-len(unit)].strip())
+                return int(value * multiplier)
+            except ValueError:
+                raise ValueError(f"Invalid numeric value in size string: '{size_str}'")
+
+    raise ValueError(f"Unrecognized size unit in '{size_str}'. Must be KB, MB, or GB.")

sima_cli/install/metadata_installer.py

@@ -0,0 +1,447 @@
+import os
+import re
+import tempfile
+import click
+import json
+import sys
+import shutil
+import tarfile
+import zipfile
+from urllib.parse import urlparse
+
+from typing import Dict
+from tqdm import tqdm
+from urllib.parse import urljoin
+from pathlib import Path
+import subprocess
+
+from rich.console import Console
+from rich.panel import Panel
+
+from huggingface_hub import snapshot_download
+
+from sima_cli.utils.disk import check_disk_space
+from sima_cli.utils.env import get_environment_type, get_exact_devkit_type
+from sima_cli.download.downloader import download_file_from_url
+from sima_cli.install.metadata_validator import validate_metadata, MetadataValidationError
+from sima_cli.install.metadata_info import print_metadata_summary, parse_size_string_to_bytes
+
+console = Console()
+
+def _download_assets(metadata: dict, base_url: str, dest_folder: str, internal: bool = False, skip_models: bool = False) -> list:
+    """
+    Downloads resources defined in metadata to a local destination folder.
+
+    Args:
+        metadata (dict): Parsed and validated metadata
+        base_url (str): Base URL of the metadata file (used to resolve relative resource paths)
+        dest_folder (str): Local path to download resources into
+        internal (bool): Whether to use internal download routing (if applicable)
+        skip_models (bool): If True, skips downloading any file path starting with 'models/'
+
+    Returns:
+        list: Paths to the downloaded local files
+    """
+    resources = metadata.get("resources", [])
+    if not resources:
+        raise click.ClickException("❌ No 'resources' defined in metadata.")
+
+    os.makedirs(dest_folder, exist_ok=True)
+    local_paths = []
+
+    filtered_resources = []
+    for r in resources:
+        if skip_models and r.strip().lower().startswith("models/"):
+            click.echo(f"⏭️  Skipping model file: {r}")
+            continue
+        filtered_resources.append(r)
+
+    if not filtered_resources:
+        click.echo("ℹ️ No non-model resources to download.")
+        return []
+
+    click.echo(f"📥 Downloading {len(filtered_resources)} resource(s) to: {dest_folder}\n")
+
+    for resource in filtered_resources:
+        try:
+            # Handle Hugging Face snapshot-style URL: "hf:<repo_id>@version"
+            if resource.startswith("hf:"):
+                # Strip prefix and split by @
+                resource_spec = resource[3:]
+                if "@" in resource_spec:
+                    repo_id, revision = resource_spec.split("@", 1)
+                else:
+                    repo_id, revision = resource_spec, None
+
+                if "/" not in repo_id:
+                    raise click.ClickException(f"❌ Invalid Hugging Face repo spec: {resource}")
+
+                org, name = repo_id.split("/", 1)
+                target_dir = os.path.join(dest_folder, name)
+
+                click.echo(f"🤗 Downloading Hugging Face repo: {repo_id}" + (f"@{revision}" if revision else ""))
+                model_path = snapshot_download(
+                    repo_id=repo_id,
+                    local_dir=target_dir,
+                    revision=revision  # None if not specified
+                )
+                local_paths.append(model_path)
+                continue
+
+            # Handle normal relative or absolute URLs
+            resource_url = urljoin(base_url, resource)
+            local_path = download_file_from_url(
+                url=resource_url,
+                dest_folder=dest_folder,
+                internal=internal
+            )
+            click.echo(f"✅ Downloaded: {resource}")
+            local_paths.append(local_path)
+
+        except Exception as e:
+            raise click.ClickException(f"❌ Failed to download resource '{resource}': {e}")
+
+    return local_paths
+
+def _download_and_validate_metadata(metadata_url, internal=False):
+    """
+    Downloads (if remote), validates, and parses metadata from a given URL or local file path.
+
+    Args:
+        metadata_url (str): URL or local path to a metadata.json file
+        internal (bool): Whether to use internal mirrors or logic in downloader
+
+    Returns:
+        tuple: (parsed metadata dict, folder containing the metadata file)
+    """
+    try:
+        parsed = urlparse(metadata_url)
+
+        # Case 1: Local file (e.g., /path/to/file or ./file)
+        if parsed.scheme == "" or parsed.scheme == "file":
+            metadata_path = parsed.path
+            if not os.path.isfile(metadata_path):
+                raise FileNotFoundError(f"File not found: {metadata_path}")
+            click.echo(f"📄 Using local metadata file: {metadata_path}")
+
+        # Case 2: Remote URL
+        else:
+            with tempfile.TemporaryDirectory() as tmpdir:
+                metadata_path = download_file_from_url(
+                    url=metadata_url,
+                    dest_folder=tmpdir,
+                    internal=internal
+                )
+                click.echo(f"⬇️  Downloaded metadata to: {metadata_path}")
+                
+                # Must copy to outside tmpdir since tmpdir will be deleted
+                # But since we're returning contents only, no need to keep file
+                with open(metadata_path, "r", encoding="utf-8") as f:
+                    metadata = json.load(f)
+                validate_metadata(metadata)
+                click.echo("✅ Metadata validated successfully.")
+                return metadata, os.path.dirname(metadata_path)
+
+        # Common validation logic for local file
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            metadata = json.load(f)
+
+        validate_metadata(metadata)
+        click.echo("✅ Metadata validated successfully.")
+        return metadata, os.path.dirname(os.path.abspath(metadata_path))
+
+    except MetadataValidationError as e:
+        click.echo(f"❌ Metadata validation failed: {e}")
+        raise click.Abort()
+
+    except Exception as e:
+        click.echo(f"❌ Failed to retrieve or parse metadata from {metadata_url}: {e}")
+        raise click.Abort()
+    
+def _check_whether_disk_is_big_enough(metadata: dict):
+    # Step 3: Disk space check
+    try:
+        install_size_str = metadata.get("size", {}).get("install")
+        if install_size_str:
+            required_bytes = parse_size_string_to_bytes(install_size_str)
+            if not check_disk_space(required_bytes, folder="."):
+                required_gb = required_bytes / 1e9
+                raise click.ClickException(
+                    f"Not enough disk space. At least {required_gb:.2f} GB required the in current directory."
+                )
+
+            available_bytes = shutil.disk_usage(".").free
+            available_gb = available_bytes / 1e9
+            required_gb = required_bytes / 1e9
+            click.echo(f"🗄️  Available disk space: {available_gb:.2f} GB")
+            click.echo(f"✅ Enough disk space for installation: requires {required_gb:.2f} GB")
+            return True
+    except Exception as e:
+        click.echo(f"❌ Failed to validate disk space: {e}")
+        raise click.Abort()
+
+    return False
+
+def _extract_tar_streaming(tar_path: Path, extract_dir: Path):
+    """
+    Extract tar while preserving full folder structure.
+    """
+    extracted_files = 0
+    with tarfile.open(tar_path, "r:*") as tar:
+        with tqdm(desc=f"📦 Extracting {tar_path.name}", unit=" file") as pbar:
+            while True:
+                member = tar.next()
+                if member is None:
+                    break
+
+                # Don't strip anything — preserve full path
+                if not member.name.strip():
+                    print(f"⚠️ Skipping empty member in archive: {member}")
+                    continue
+
+                tar.extract(member, path=extract_dir)
+                extracted_files += 1
+                pbar.update(1)
+
+    print(f"✅ Extracted {extracted_files} files to {extract_dir}/")
+
+def _extract_zip_streaming(zip_path: Path, extract_dir: Path):
+    """
+    Extract a .zip file using streaming to avoid NFS slowness from metadata calls,
+    and flatten one top-level directory if present.
+    """
+    with zipfile.ZipFile(zip_path, "r") as zipf:
+        members = zipf.infolist()
+        with tqdm(total=len(members), desc=f"📦 Extracting {zip_path.name}", unit="file") as pbar:
+            for member in members:
+                # Strip one top-level directory if it exists
+                parts = Path(member.filename).parts
+                if len(parts) > 1:
+                    stripped_path = Path(*parts[1:])
+                else:
+                    stripped_path = Path(parts[-1])
+
+                target_path = extract_dir / stripped_path
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+
+                with zipf.open(member) as src, open(target_path, "wb") as dst:
+                    shutil.copyfileobj(src, dst)
+
+                pbar.update(1)
+
+    print(f"✅ Extracted {len(members)} files to {extract_dir}/")
+
+def _combine_multipart_files(folder: str):
+    """
+    Scan a folder for multipart files like name-split-aa, -ab, etc.,
+    combine them into a single file, and remove the split parts.
+    Then auto-extract .tar files with progress.
+    """
+    folder = Path(folder)
+    parts_by_base = {}
+
+    # Step 1: Group parts by base name
+    for file in folder.iterdir():
+        if not file.is_file():
+            continue
+
+        match = re.match(r"(.+)-split-([a-z]{2})$", file.name)
+        if match:
+            base, part = match.groups()
+            parts_by_base.setdefault(base, []).append((part, file))
+
+    # Step 2: Process each group
+    for base, parts in parts_by_base.items():
+        parts.sort(key=lambda x: x[0])
+        output_file = folder / f"{base}.tar"
+        total_size = sum(part_file.stat().st_size for _, part_file in parts)
+
+        print(f"\n🧩 Reassembling: {output_file.name} from {len(parts)} parts")
+
+        if not output_file.exists():
+            with open(output_file, "wb") as outfile, tqdm(
+                total=total_size,
+                unit="B",
+                unit_scale=True,
+                unit_divisor=1024,
+                desc=f"Combining {output_file.name}",
+            ) as pbar:
+                for _, part_file in parts:
+                    with open(part_file, "rb") as infile:
+                        while True:
+                            chunk = infile.read(1024 * 1024)  # 1MB
+                            if not chunk:
+                                break
+                            outfile.write(chunk)
+                            pbar.update(len(chunk))
+
+        # Step 3: Remove original parts
+        # for _, part_file in parts:
+        #     part_file.unlink()
+
+        print(f"✅ Created: {output_file.name} ({output_file.stat().st_size / 1e6:.2f} MB)")
+
+        # Step 4: Auto-extract .tar
+        extract_dir = folder / base
+        print(f"📦 Extracting {output_file.name} to {extract_dir}/")
+        _extract_tar_streaming(output_file, extract_dir)
+
+        print(f"✅ Extracted to: {extract_dir}/")
+
+def _extract_archives_in_folder(folder: str):
+    """
+    Extract all .tar.gz and .zip files in the given folder into subdirectories.
+    Uses streaming to avoid NFS performance issues.
+    """
+    folder = Path(folder)
+    for file in folder.iterdir():
+        if not file.is_file():
+            continue
+
+        # TAR.GZ
+        if file.suffixes == [".tar", ".gz"] or file.name.endswith(".tar.gz"):
+            extract_dir = folder / file.stem.replace(".tar", "")
+            print(f"📦 Extracting TAR.GZ: {file.name} to {extract_dir}/")
+            _extract_tar_streaming(file, extract_dir)
+
+        # ZIP
+        elif file.suffix == ".zip":
+            extract_dir = folder / file.stem
+            print(f"📦 Extracting ZIP: {file.name} to {extract_dir}/")
+            _extract_zip_streaming(file, extract_dir)
+
+def _is_platform_compatible(metadata: dict) -> bool:
+    """
+    Determines if the current environment is compatible with the package metadata.
+
+    Args:
+        metadata (dict): Metadata that includes a 'platforms' section
+
+    Returns:
+        bool: True if compatible, False otherwise
+    """
+    env_type, env_subtype = get_environment_type()
+    exact_devkit_type = get_exact_devkit_type()
+    platforms = metadata.get("platforms", [])
+
+    for i, platform_entry in enumerate(platforms):
+        platform_type = platform_entry.get("type")
+        if platform_type != env_type:
+            continue
+
+        # For board/devkit: check compatible_with list
+        if env_type == "board":
+            compat = platform_entry.get("compatible_with", [])
+            if env_subtype not in compat and exact_devkit_type not in compat:
+                continue
+
+        # For host/sdk/generic: optionally check OS match
+        if "os" in platform_entry:
+            supported_oses = [os_name.lower() for os_name in platform_entry["os"]]
+            if env_subtype.lower() not in supported_oses:
+                continue
+
+        # Passed all checks
+        return True
+
+    click.echo(f"❌ Current environment [{env_type}:{env_subtype}] is not compatible with the package")
+    return False
+
+
+def _print_post_install_message(metadata: Dict):
+    """
+    Print post-installation instructions from the metadata in a compact box.
+
+    Args:
+        metadata (Dict): The package metadata dictionary.
+    """
+    msg = metadata.get("installation", {}).get("post-message", "").strip()
+
+    if msg:
+        panel = Panel.fit(
+            msg,
+            title="[bold green]Post-Installation Instructions[/bold green]",
+            title_align="left",
+            border_style="green",
+            padding=(1, 2)
+        )
+        console.print(panel)
+
+def _run_installation_script(metadata: Dict, extract_path: str = "."):
+    """
+    Run the installation script specified in the metadata.
+
+    Args:
+        metadata (dict): Metadata dictionary with an 'installation' key.
+        extract_path (str): Path where the files were extracted.
+    """
+    script = metadata.get("installation", {}).get("script", "").strip()
+    if not script:
+        print("⚠️ No installation script provided. Follow package documentation to install the package.")
+        return
+
+    print(f"🚀 Running installation script in: {os.path.abspath(extract_path)}")
+    print(f"📜 Script: {script}")
+
+    # Determine shell type based on platform
+    shell_executable = os.environ.get("COMSPEC") if os.name == "nt" else None
+
+    try:
+        subprocess.run(
+            script,
+            shell=True,
+            executable=shell_executable,
+            cwd=extract_path,
+            check=True
+        )
+        _print_post_install_message(metadata=metadata)        
+    except subprocess.CalledProcessError as e:
+        print("❌ Installation failed with return code:", e.returncode)
+        sys.exit(e.returncode)
+
+    print("✅ Installation completed successfully.")
+
+def install_from_metadata(metadata_url: str, internal: bool, install_dir: str = '.'):
+    try:
+        metadata, _ = _download_and_validate_metadata(metadata_url, internal)
+        print_metadata_summary(metadata=metadata)
+
+        if _check_whether_disk_is_big_enough(metadata):
+            if _is_platform_compatible(metadata):
+                local_paths = _download_assets(metadata, metadata_url, install_dir, internal)
+                if len(local_paths) > 0:
+                    _combine_multipart_files(install_dir)
+                    _extract_archives_in_folder(install_dir)
+                    _run_installation_script(metadata=metadata, extract_path=install_dir)
+
+    except Exception as e:
+        click.echo(f"❌ Failed to install from metadata URL {metadata_url}: {e}")
+        exit(1)
+
+    return False
+
+def metadata_resolver(component: str, version: str = None, tag: str = None) -> str:
+    """
+    Resolve the metadata.json URL for a given component and version/tag.
+
+    Args:
+        component (str): Component name (e.g., "examples.llima")
+        version (str): Optional SDK version string (e.g., "1.7.0")
+        tag (str): Optional tag to use (e.g., "dev")
+
+    Returns:
+        str: Fully qualified metadata URL
+    """
+    if not version:
+        raise ValueError("Version (-v) is required for non-hardcoded components.")
+
+    # Normalize version for URL path
+    sdk_path = f"SDK{version}"
+    base = f"https://docs.sima.ai/pkg_downloads/{sdk_path}/{component}"
+
+    if tag:
+        metadata_name = f"metadata-{tag}.json"
+    else:
+        metadata_name = "metadata.json"
+
+    return f"{base}/{metadata_name}"

sima_cli/install/metadata_validator.py

@@ -0,0 +1,138 @@
+import re
+import sys
+import json
+from pathlib import Path
+
+class MetadataValidationError(Exception):
+    pass
+
+VALID_TYPES = {"board", "palette", "host"}
+VALID_OS = {"linux", "windows", "mac"}
+
+def validate_metadata(data: dict):
+    # Top-level required fields
+    required_fields = ["name", "version", "release", "platforms", "resources"]
+    for field in required_fields:
+        if field not in data:
+            raise MetadataValidationError(f"Missing required field: '{field}'")
+
+    # Validate platforms
+    if not isinstance(data["platforms"], list):
+        raise MetadataValidationError("'platforms' must be a list")
+
+    for i, platform in enumerate(data["platforms"]):
+        if "type" not in platform:
+            raise MetadataValidationError(f"Missing 'type' in platform entry {i}")
+        if platform["type"] not in VALID_TYPES:
+            raise MetadataValidationError(
+                f"Invalid platform type '{platform['type']}' in entry {i}. Must be one of {VALID_TYPES}"
+            )
+
+        if platform["type"] == "board":
+            if "compatible_with" not in platform:
+                raise MetadataValidationError(f"'compatible_with' is required for board in entry {i}")
+            if not isinstance(platform["compatible_with"], list):
+                raise MetadataValidationError(f"'compatible_with' must be a list in entry {i}")
+
+        if "os" in platform:
+            if not isinstance(platform["os"], list):
+                raise MetadataValidationError(f"'os' must be a list in entry {i}")
+            for os_value in platform["os"]:
+                if os_value.lower() not in VALID_OS:
+                    raise MetadataValidationError(
+                        f"Invalid OS '{os_value}' in platform entry {i}. Supported: {VALID_OS}"
+                    )
+
+    # Validate resources
+    if not isinstance(data["resources"], list) or not data["resources"]:
+        raise MetadataValidationError("'resources' must be a non-empty list")
+
+    # Validate prerequisite (optional)
+    if "prerequisite" in data:
+        prereq = data["prerequisite"]
+        if "wheel_url" not in prereq or "entry_point" not in prereq:
+            raise MetadataValidationError("Both 'wheel_url' and 'entry_point' are required in 'prerequisite'")
+        _validate_entry_point_format(prereq["entry_point"], field="prerequisite.entry_point")
+
+    # Validate installation (optional)
+    if "installation" in data:
+        install = data["installation"]
+        if "script" not in install:
+            raise MetadataValidationError("Missing 'script' in 'installation'")
+        if not isinstance(install["script"], str):
+            raise MetadataValidationError("'installation.script' must be a string")
+
+    # Validate size (optional)
+    if "size" in data:
+        size = data["size"]
+        if not isinstance(size, dict):
+            raise MetadataValidationError("'size' must be a dictionary with 'download' and 'install' fields")
+
+        for key in ["download", "install"]:
+            if key not in size:
+                raise MetadataValidationError(f"Missing '{key}' in 'size'")
+            if not isinstance(size[key], str):
+                raise MetadataValidationError(f"'size.{key}' must be a string")
+
+            size_str = size[key].strip().upper()
+            if not any(size_str.endswith(unit) for unit in ["KB", "MB", "GB"]):
+                raise MetadataValidationError(
+                    f"'size.{key}' must end with one of: KB, MB, GB (e.g., '30GB')"
+                )
+
+            try:
+                # Extract number (e.g., "30GB" → 30.0)
+                float(size_str[:-2].strip())
+            except ValueError:
+                raise MetadataValidationError(
+                    f"'size.{key}' must start with a numeric value (e.g., '30GB')"
+                )
+
+    return True
+
+
+def _validate_entry_point_format(entry_point: str, field: str):
+    if not re.match(r"^[a-zA-Z0-9_.\-]+:[a-zA-Z0-9_]+$", entry_point):
+        raise MetadataValidationError(
+            f"Invalid format for {field}. Must be in the form 'module:function'"
+        )
+
+
+def validate_file(filepath):
+    try:
+        with open(filepath, "r") as f:
+            metadata = json.load(f)
+        validate_metadata(metadata)
+        print(f"✅ {filepath} is valid.")
+    except FileNotFoundError:
+        print(f"❌ File not found: {filepath}")
+    except json.JSONDecodeError as e:
+        print(f"❌ JSON parse error in {filepath}: {e}")
+    except MetadataValidationError as e:
+        print(f"❌ Validation failed in {filepath}: {e}")
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python validate_metadata.py <file-or-folder>")
+        sys.exit(1)
+
+    path = Path(sys.argv[1])
+
+    if not path.exists():
+        print(f"❌ Path does not exist: {path}")
+        sys.exit(1)
+
+    if path.is_file():
+        validate_file(path)
+    elif path.is_dir():
+        json_files = list(path.rglob("*.json"))
+        if not json_files:
+            print(f"⚠️ No JSON files found in directory: {path}")
+        for file in json_files:
+            validate_file(file)
+    else:
+        print(f"❌ Unsupported path type: {path}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

sima_cli/network/network.py

@@ -112,6 +112,20 @@ def get_gateway_for_interface(ip):
     parts[-1] = "1"
     return ".".join(parts)
 
+def populate_resolv_conf(dns_server="8.8.8.8"):
+    """
+    Use sudo to write a DNS entry into /etc/resolv.conf even if not running as root.
+    """
+    content = f"nameserver {dns_server}\n"
+
+    try:
+        # Write using echo and sudo tee
+        cmd = f"echo '{content.strip()}' | sudo tee /etc/resolv.conf > /dev/null"
+        result = subprocess.run(cmd, shell=True, check=True)
+        print(f"✅ /etc/resolv.conf updated with nameserver {dns_server}")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to update /etc/resolv.conf: {e}")
+
 def set_default_route(iface, ip):
     gateway = get_gateway_for_interface(ip)
     if not gateway:
@@ -182,6 +196,7 @@ def network_menu():
 
         if second == "Set to DHCP":
             move_network_file(selected_iface["name"], "dhcp")
+            populate_resolv_conf()
         elif second == "Set to Default Static IP":
             move_network_file(selected_iface["name"], "static")
         elif second == "Set as Default Route":

sima_cli/nvme/nvme.py

@@ -56,8 +56,27 @@ def add_nvme_to_fstab():
         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)
+    try:
+        # Create mount point
+        subprocess.run("sudo mkdir -p /mnt/nvme", shell=True, check=True)
+
+        # Mount the NVMe partition
+        subprocess.run("sudo mount /dev/nvme0n1p1 /mnt/nvme", shell=True, check=True)
+
+        add_nvme_to_fstab()
+
+        subprocess.run("sudo mount -a", shell=True, check=True)
+        
+        # Change ownership to user 'sima'
+        subprocess.run("sudo chown sima:sima /mnt/nvme", shell=True, check=True)
+
+        subprocess.run("sudo chmod 755 /mnt/nvme", shell=True, check=True)
+
+
+        print("✅ NVMe mounted and write permission granted to user 'sima'.")
+
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error during NVMe mount: {e}")
 
 def nvme_format():
     if not is_modalix_devkit():
@@ -87,8 +106,6 @@ def nvme_format():
         # Format and mount
         format_nvme(lbaf_index)
         mount_nvme()
-        add_nvme_to_fstab()
-
         click.echo("✅  NVMe drive formatted and mounted at /mnt/nvme.")
     except subprocess.CalledProcessError:
         click.echo("❌ Formatting process failed.")
@@ -100,13 +117,7 @@ def nvme_remount():
         return
 
     try:
-        # Ensure mount point exists
-        subprocess.run("sudo mkdir -p /mnt/nvme", shell=True, check=True)
-        # Mount the partition
-        subprocess.run("sudo mount /dev/nvme0n1p1 /mnt/nvme", shell=True, check=True)
-
-        # Add NVME to fstab
-        add_nvme_to_fstab()
+        mount_nvme()
 
     except subprocess.CalledProcessError as e:
         raise RuntimeError(f"Failed to remount NVMe: {e}")

sima_cli/update/updater.py

@@ -448,7 +448,7 @@ def perform_update(version_or_url: str, ip: str = None, internal: bool = False,
             board, version, fdt_name = get_remote_board_info(ip, passwd)
 
         if board in ['davinci', 'modalix']:
-            click.echo(f"🔧 Target board: {board}, board currently running: {version}")
+            click.echo(f"🔧 Target board: {board} {fdt_name}, board currently running: {version}")
             
             if flavor == 'full' and fdt_name != 'modalix-som.dtb':
                 click.echo(f"❌ You've requested updating {fdt_name} to full image, this is only supported for the Modalix DevKit")

sima_cli/utils/disk.py

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

sima_cli/utils/env.py

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

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

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

{sima_cli-0.0.21.dist-info → sima_cli-0.0.22.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=5C0RJVUsHkVkCFWA58oGCy10CpKRe_uE6H3nKgYCdRk,49
-sima_cli/cli.py,sha256=OwoMg0UFl4Qy4FTCj5fXSNg-BjhC91dPYeZRSr15gBs,14447
+sima_cli/__version__.py,sha256=lZAZ5KAyL1sCs70SHAhw90CQC4944919Ga30NNcR4_g,49
+sima_cli/cli.py,sha256=dO6MG8sBX7LKJ-FhPQf7bw8oqSlosDXKcBaVbCIDZWQ,16056
 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
@@ -10,16 +10,19 @@ sima_cli/auth/login.py,sha256=yCYXWgrfbP4jSTZ3hITfxlgHkdVQVzsd8hQKpqaqCKs,3780
 sima_cli/data/resources_internal.yaml,sha256=zlQD4cSnZK86bLtTWuvEudZTARKiuIKmB--Jv4ajL8o,200
 sima_cli/data/resources_public.yaml,sha256=U7hmUomGeQ2ULdo1BU2OQHr0PyKBamIdK9qrutDlX8o,201
 sima_cli/download/__init__.py,sha256=6y4O2FOCYFR2jdnQoVi3hRtEoZ0Gw6rydlTy1SGJ5FE,218
-sima_cli/download/downloader.py,sha256=pHfqcg_ujBQjds_EkcRV85M2mRYGrysoZaiR-FIrpf4,5161
+sima_cli/download/downloader.py,sha256=nCBrr_0WdnKTIyecwKpg1sCdfm_4PSQTRPwEbiezy8M,5339
 sima_cli/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sima_cli/install/hostdriver.py,sha256=kAWDLebs60mbWIyTbUxmNrChcKW1uD5r7FtWNSUVUE4,5852
+sima_cli/install/metadata_info.py,sha256=wmMqwzGfXbuilkqaxRVrFOzOtTOiONkmPCyA2oDAQpA,2168
+sima_cli/install/metadata_installer.py,sha256=mtwtBEMmLh6-Hqtv6CTTAQa76sRJXZCqE9ORPQutfcc,16547
+sima_cli/install/metadata_validator.py,sha256=7954rp9vFRNnqmIMvCVTjq40kUIEbGXzfc8HmQmChe0,5221
 sima_cli/install/optiview.py,sha256=i5eWVor-9MScEfrQm3Ty9OP4VpSsCgWvNh7AvYdZu7s,3365
 sima_cli/install/palette.py,sha256=uRznoHa4Mv9ZXHp6AoqknfC3RxpYNKi9Ins756Cyifk,3930
 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/network/network.py,sha256=ToDCQBfX0bUFEWWtfS8srImK5T11MX6R4MBQFM80faY,7617
+sima_cli/nvme/nvme.py,sha256=ECdd25fvFbs5T5_PlIwnxm3NiPNmqnFGXrgLZhLENRY,4129
 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
@@ -31,15 +34,16 @@ 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/update/updater.py,sha256=vBdT0Im0a0iKwB-LzVDZasnXk2Rq-kNlBGr7bTG0-14,20879
 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=m6yRnNuajYWTfysPJLk6vJY9Z1kYGFIAaArnpHXhino,6411
+sima_cli/utils/disk.py,sha256=66Kr631yhc_ny19up2aijfycWfD35AeLQOJgUsuH2hY,446
+sima_cli/utils/env.py,sha256=bNushG2BD243fNlqCpuUJxLF76inRxTFeSDkl_KCHy0,7130
 sima_cli/utils/net.py,sha256=WVntA4CqipkNrrkA4tBVRadJft_pMcGYh4Re5xk3rqo,971
 sima_cli/utils/network.py,sha256=UvqxbqbWUczGFyO-t1SybG7Q-x9kjUVRNIn_D6APzy8,1252
-sima_cli-0.0.21.dist-info/licenses/LICENSE,sha256=a260OFuV4SsMZ6sQCkoYbtws_4o2deFtbnT9kg7Rfd4,1082
+sima_cli-0.0.22.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
@@ -48,8 +52,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.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,,
+sima_cli-0.0.22.dist-info/METADATA,sha256=3LetoBbyq_AopItmkPCqz3BBWL2_osKmaPHd_Vh8038,3705
+sima_cli-0.0.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sima_cli-0.0.22.dist-info/entry_points.txt,sha256=xRYrDq1nCs6R8wEdB3c1kKuimxEjWJkHuCzArQPT0Xk,47
+sima_cli-0.0.22.dist-info/top_level.txt,sha256=FtrbAUdHNohtEPteOblArxQNwoX9_t8qJQd59fagDlc,15
+sima_cli-0.0.22.dist-info/RECORD,,