sima-cli 2.1.11__tar.gz → 2.1.12__tar.gz

{sima_cli-2.1.11/sima_cli.egg-info → sima_cli-2.1.12}/PKG-INFO

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

{sima_cli-2.1.11 → sima_cli-2.1.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sima-cli"
-version = "2.1.11"
+version = "2.1.12"
 description = "CLI tool for SiMa Developer Portal to download models, firmware, and apps."
 readme = "README.md"
 requires-python = ">=3.8"

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/__version__.py

@@ -1,2 +1,2 @@
 # sima_cli/__version__.py
-__version__ = "2.1.11"
+__version__ = "2.1.12"

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/auth/auth0.py

@@ -286,7 +286,7 @@ def request_device_code(auth_cfg):
 
 def poll_for_token(auth_cfg, device_code, interval):
     """Step 2: Poll for user authorization."""
-    print(f"⏳ Waiting for user authorization... polling every {interval} seconds.")
+    print(f"⏳ Waiting for authorization. Complete the browser login above; checking every {interval} seconds.")
     while True:
         time.sleep(interval)
         resp = requests.post(
@@ -333,16 +333,21 @@ def login_auth0(auth_cfg):
     highlighted_url = click.style(verify_complete, fg="cyan", bold=True)
     highlighted_code = click.style(user_code, fg="yellow", bold=True)
 
-    print(f"⏰ Link expires in {expires_in} minutes.\n")
+    print("🔐 sima-cli needs you to authorize this device login.")
+    print(f"⏰ Login link/code expires in {expires_in} minutes.\n")
 
     # Auto-open browser if possible
-    if is_browser_available() and verify_complete:
+    if is_browser_available() and verify_complete and webbrowser.open(verify_complete):
         print(f"🌐 Opening browser for login → {highlighted_url}")
-        webbrowser.open(verify_complete)
+        print("After signing in, return to this terminal. sima-cli will continue automatically.")
     else:
-        print("🔐 Browser not available — open manually:")
-        print(f"   👉 {highlighted_url}")
-        print(f"   🪄  Code: {highlighted_code}")
+        print("⚠️  A browser could not be opened from this environment.")
+        print("Action required:")
+        print("  1. Open this URL in a browser on your workstation:")
+        print(f"     {highlighted_url}")
+        print("  2. Sign in with your SiMa Developer Portal account.")
+        print(f"  3. If prompted, confirm this code: {highlighted_code}")
+        print("  4. Return to this terminal. sima-cli will continue automatically after authorization.")
 
     return poll_for_token(auth_cfg, data["device_code"], data["interval"])
 

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/auth/devportal.py

@@ -69,8 +69,17 @@ HEADERS = {
 
 
 def _prompt_manual_developer_portal_login(confirm_completion: bool = False) -> bool:
+    next_step = (
+        "After signing in and accepting the EULA, return here and confirm when prompted."
+        if confirm_completion
+        else "After signing in and accepting the EULA, rerun the command that required authentication."
+    )
     click.secho(
-        f"\nOpen this page to accept EULA to proceed, press Y when you are done:\n{DEV_PORTAL_LOGIN_URL}\n",
+        "\nA browser could not be opened from this environment.\n"
+        "Open the following URL in a browser on your workstation to authenticate "
+        "with the SiMa Developer Portal and accept the EULA if prompted:\n\n"
+        f"{DEV_PORTAL_LOGIN_URL}\n\n"
+        f"{next_step}\n",
         fg="green",
     )
     if confirm_completion:

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/cli.py

@@ -579,7 +579,7 @@ ALL_COMPONENTS = SDK_DEPENDENT_COMPONENTS | SDK_INDEPENDENT_COMPONENTS
     default=".",
     show_default=True,
     type=click.Path(file_okay=False, dir_okay=True, path_type=str),
-    help="Directory where Neat package resources are downloaded and installed. Used with --neat or --vulcan.",
+    help="Directory where package resources are downloaded and installed.",
 )
 @click.option("--json", "json_output", is_flag=True, help="With --neat or --vulcan, print resolved metadata URL and exit.")
 @click.option(
@@ -655,6 +655,7 @@ def install_cmd(
             install_dir=install_dir,
             force=force,
             json_output=json_output,
+            command_name="sima-cli install",
         )
         return None
 
@@ -663,7 +664,13 @@ def install_cmd(
         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}")
-        install_from_metadata(metadata_url=mirror, internal=internal, force=force)
+        install_from_metadata(
+            metadata_url=mirror,
+            internal=internal,
+            install_dir=install_dir,
+            force=force,
+            command_name="sima-cli install",
+        )
         return None
 
     # No component and no metadata: error
@@ -673,7 +680,13 @@ def install_cmd(
 
     # if user specified gh: as component, treat it the same as -m
     if component.startswith("gh:"):
-        install_from_metadata(metadata_url=component, internal=False, force=force)
+        install_from_metadata(
+            metadata_url=component,
+            internal=False,
+            install_dir=install_dir,
+            force=force,
+            command_name="sima-cli install",
+        )
         return None
     
     # if the user specified cr: or ghcr: as component, install from container registry
@@ -707,8 +720,16 @@ def install_cmd(
         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, force=force):
+            if install_from_metadata(
+                metadata_url=metadata_url,
+                internal=internal,
+                install_dir=install_dir,
+                force=force,
+                command_name="sima-cli install",
+            ):
                 click.echo("✅ Installation complete.")
+        except click.ClickException:
+            raise
         except Exception as e:
             click.echo(f"❌ Failed to resolve metadata for component '{component}': {e}")
             ctx.exit(1)

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/install/compatibility.py

@@ -1,3 +1,4 @@
+import platform
 import re
 from typing import Dict, List, Optional, Sequence
 
@@ -51,6 +52,33 @@ def validate_version_spec(spec: str) -> None:
     normalize_version_spec(spec)
 
 
+def normalize_host_arch(arch: str) -> str:
+    if not isinstance(arch, str) or not arch.strip():
+        raise ValueError("host architecture must be a non-empty string")
+    normalized = arch.strip().lower()
+    aliases = {
+        "x86_64": "amd64",
+        "amd64": "amd64",
+        "aarch64": "arm64",
+        "arm64": "arm64",
+    }
+    if normalized not in aliases:
+        raise ValueError(
+            "invalid host architecture '{}'; supported values are amd64, arm64, x86_64, aarch64".format(
+                arch
+            )
+        )
+    return aliases[normalized]
+
+
+def current_host_arch() -> str:
+    machine = platform.machine().lower()
+    try:
+        return normalize_host_arch(machine)
+    except ValueError:
+        return machine
+
+
 def normalize_exact_version(version: str) -> str:
     if not isinstance(version, str) or not version.strip():
         raise ValueError("version must be a non-empty string")
@@ -92,25 +120,48 @@ def version_matches(version: str, spec: str) -> bool:
     return True
 
 
-def parse_host_platform_specs(host_platforms: Optional[Sequence[str]]) -> List[Dict]:
+def parse_host_platform_specs(
+    host_platforms: Optional[Sequence[str]],
+    host_arches: Optional[Sequence[str]] = None,
+) -> List[Dict]:
+    normalized_arches = []
+    seen_arches = set()
+    for raw_arch in host_arches or []:
+        for value in _split_csv(raw_arch):
+            arch = normalize_host_arch(value)
+            if arch not in seen_arches:
+                seen_arches.add(arch)
+                normalized_arches.append(arch)
+
     platforms = []
     for raw_spec in host_platforms or []:
         os_values = []
+        versions = {}
         seen = set()
         for value in _split_csv(raw_spec):
-            os_value = value.lower()
+            raw_os, separator, raw_version_spec = value.partition("@")
+            os_value = raw_os.lower()
             if os_value not in VALID_OS:
                 raise ValueError(
                     "invalid host platform OS '{}'; supported values are {}".format(
-                        value, ", ".join(sorted(VALID_OS))
+                        raw_os, ", ".join(sorted(VALID_OS))
                     )
                 )
             if os_value not in seen:
                 seen.add(os_value)
                 os_values.append(os_value)
+            if separator:
+                versions.setdefault(os_value, []).append(normalize_version_spec(raw_version_spec))
         if not os_values:
             raise ValueError("host platform spec must include at least one OS")
-        platforms.append({"type": "host", "os": os_values})
+        platform_spec = {"type": "host", "os": os_values}
+        if versions:
+            platform_spec["versions"] = versions
+        if normalized_arches:
+            platform_spec["arch"] = list(normalized_arches)
+        platforms.append(platform_spec)
+    if normalized_arches and not platforms:
+        raise ValueError("--host-arch requires at least one --host-platform entry")
     return platforms
 
 
@@ -147,11 +198,12 @@ def parse_board_platform_specs(board_platforms: Optional[Sequence[str]]) -> List
 
 def build_platform_specs(
     host_platforms: Optional[Sequence[str]] = None,
+    host_arches: Optional[Sequence[str]] = None,
     board_platforms: Optional[Sequence[str]] = None,
     palette_platform: Optional[str] = None,
 ) -> List[Dict]:
     platforms = []
-    platforms.extend(parse_host_platform_specs(host_platforms))
+    platforms.extend(parse_host_platform_specs(host_platforms, host_arches=host_arches))
     platforms.extend(parse_board_platform_specs(board_platforms))
     if palette_platform is not None:
         platform = {"type": "palette"}

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/install/metadata_installer.py

@@ -20,6 +20,7 @@ import requests
 
 from rich.console import Console
 from rich.panel import Panel
+from rich.text import Text
 from typing import Tuple
 
 from huggingface_hub import snapshot_download
@@ -28,7 +29,7 @@ from sima_cli.utils.disk import check_disk_space
 from sima_cli.utils.env import get_environment_type, get_exact_devkit_type, get_sima_build_version
 from sima_cli.download.downloader import download_file_from_url
 from sima_cli.install.metadata_validator import validate_metadata, MetadataValidationError
-from sima_cli.install.compatibility import version_matches
+from sima_cli.install.compatibility import current_host_arch, normalize_host_arch, version_matches
 from sima_cli.install.metadata_info import print_metadata_summary, parse_size_string_to_bytes
 from sima_cli.utils.container_registries import install_from_cr
 from sima_cli.install.registry import PackageRegistry
@@ -36,6 +37,52 @@ from sima_cli.install.registry import PackageRegistry
 console = Console()
 registry = PackageRegistry()
 
+class InstallationPreflightError(click.ClickException):
+    def show(self, file=None) -> None:
+        console.print(
+            Panel(
+                Text(str(self.message), style="yellow"),
+                title="Installation Failed",
+                border_style="yellow",
+                expand=False,
+            )
+        )
+
+
+def _ensure_install_dir_writable(install_dir: str, command_name: str = "sima-cli install") -> None:
+    target = Path(install_dir or ".").expanduser()
+    display_path = Path.cwd() if str(target) == "." else target
+
+    check_dir = target
+    if not check_dir.exists():
+        check_dir = target.parent
+        while not check_dir.exists() and check_dir != check_dir.parent:
+            check_dir = check_dir.parent
+
+    if not check_dir.is_dir():
+        raise click.ClickException(f"Install path '{display_path}' is not a directory.")
+
+    try:
+        with tempfile.NamedTemporaryFile(prefix=".sima-cli-write-test-", dir=str(check_dir)):
+            pass
+    except OSError as exc:
+        if str(target) == ".":
+            raise InstallationPreflightError(
+                f"Current directory '{Path.cwd()}' is not writable.\n\n"
+                "This install downloads package assets into the current directory before installation.\n\n"
+                "Run the command again from a writable work directory, for example:\n"
+                "  mkdir -p ~/sima-install && cd ~/sima-install\n"
+                f"  {command_name} ...\n\n"
+                "Or choose a destination explicitly:\n"
+                f"  {command_name} ... --install-dir <writable-directory>"
+            ) from exc
+        raise InstallationPreflightError(
+            f"Install directory '{display_path}' is not writable.\n\n"
+            "This install downloads package assets into the install directory before installation.\n\n"
+            "Choose a writable destination and rerun the command:\n"
+            f"  {command_name} ... --install-dir <writable-directory>"
+        ) from exc
+
 def _copy_dir(src: Path, dest: Path, label: str):
     """
     Copy files from src → dest, merging with existing files (no deletion).
@@ -1065,23 +1112,26 @@ def _print_compatible_platforms(platforms):
     table.add_column("Platform Type", style="bold cyan", no_wrap=True)
     table.add_column("Details", style="bold yellow")
     table.add_column("Supported Versions / Targets", style="white")
+    table.add_column("Arch", style="white")
 
     for p in platforms:
         ptype = p.get("type", "N/A")
 
         if ptype == "host":
+            arch = ", ".join(p.get("arch") or ["All"])
+            versions_by_os = {str(k).lower(): v for k, v in p.get("versions", {}).items()}
             for os_name in p.get("os", []):
-                versions = p.get("versions", {}).get(os_name, ["All"])
-                table.add_row(ptype, os_name.capitalize(), ", ".join(versions))
+                versions = versions_by_os.get(str(os_name).lower(), ["All"])
+                table.add_row(ptype, os_name.capitalize(), ", ".join(versions), arch)
 
         elif ptype == "board":
             compat = p.get("compatible_with", [])
             version = p.get("version", "All")
             compat_text = ", ".join(compat) if compat else "N/A"
-            table.add_row(ptype, compat_text, version)
+            table.add_row(ptype, compat_text, version, "N/A")
 
         else:
-            table.add_row(ptype, "N/A", "N/A")
+            table.add_row(ptype, "N/A", "N/A", "N/A")
 
     console.print(table)
     console.print()
@@ -1091,8 +1141,14 @@ def _compare_versions(current: str, condition: str) -> bool:
     Compare current version (e.g. '15.5') against a condition string like:
       '>=12', '<=16', '>20.04', '<23.0', '14'
     """
-    cur = _version_to_tuple(current)
     cond = condition.strip()
+    if re.match(r"^(>=|<=|==|=|>|<)", cond):
+        try:
+            return version_matches(current, cond)
+        except ValueError:
+            pass
+
+    cur = _version_to_tuple(current)
 
     # Detect operator and target
     match = re.match(r"^(>=|<=|>|<|=)?\s*([\d.]+)$", cond)
@@ -1128,6 +1184,73 @@ def _get_palette_sdk_version(release_file: Path = Path("/etc/sdk-release")) -> s
     return match.group(1).split("_", 1)[0].strip()
 
 
+def _detected_host_platform() -> tuple:
+    os_name = platform.system().lower()
+    os_version = "Unknown"
+
+    if os_name == "darwin":
+        return "mac", platform.mac_ver()[0] or "Unknown", current_host_arch()
+    if os_name == "windows":
+        return "windows", platform.release() or "Unknown", current_host_arch()
+    if os_name != "linux":
+        return os_name, os_version, current_host_arch()
+
+    os_release = {}
+    try:
+        with open("/etc/os-release", encoding="utf-8") as f:
+            for line in f:
+                key, separator, value = line.strip().partition("=")
+                if separator:
+                    os_release[key] = value.strip().strip('"')
+    except OSError:
+        os_release = {}
+
+    distro_id = (os_release.get("ID") or "").lower()
+    version_id = os_release.get("VERSION_ID") or ""
+    if distro_id == "ubuntu":
+        os_name = "ubuntu"
+        os_version = version_id or "Unknown"
+    else:
+        os_name = "linux"
+        os_version = version_id or "Unknown"
+
+    if os_version == "Unknown":
+        try:
+            out = subprocess.check_output(["lsb_release", "-ds"], text=True).strip().lower()
+            if "ubuntu" in out:
+                os_name = "ubuntu"
+            match = re.search(r"(\d+\.\d+|\d+)", out)
+            os_version = match.group(1) if match else "Unknown"
+        except Exception:
+            pass
+
+    match = re.search(r"(\d+\.\d+|\d+)", os_version)
+    if match:
+        os_version = match.group(1)
+    return os_name, os_version, current_host_arch()
+
+
+def _host_os_matches(detected_os: str, supported_oses: List[str]) -> bool:
+    if detected_os in supported_oses:
+        return True
+    return detected_os == "ubuntu" and "linux" in supported_oses
+
+
+def _host_versions_for_os(platform_entry: dict, detected_os: str) -> list:
+    versions_dict = {str(k).lower(): v for k, v in platform_entry.get("versions", {}).items()}
+    return versions_dict.get(detected_os) or (versions_dict.get("linux") if detected_os == "ubuntu" else []) or []
+
+
+def _host_arch_matches(platform_entry: dict, detected_arch: str) -> bool:
+    supported_arches = []
+    for value in platform_entry.get("arch", []):
+        try:
+            supported_arches.append(normalize_host_arch(value))
+        except ValueError:
+            supported_arches.append(str(value).lower())
+    return not supported_arches or detected_arch in supported_arches
+
+
 def _is_platform_compatible(metadata: dict, force: bool = False) -> bool:
     """
     Determines if the current environment is compatible with the package metadata.
@@ -1142,40 +1265,7 @@ def _is_platform_compatible(metadata: dict, force: bool = False) -> bool:
         click.echo("ℹ️  No platform restrictions specified; treating package as compatible with all platforms.")
         return True
 
-    # Detect current OS and version
-    os_name = platform.system().lower()  # 'darwin', 'windows', 'linux'
-    os_version = "Unknown"
-
-    if os_name == "darwin":
-        os_name = "mac"
-        os_version = platform.mac_ver()[0] or "Unknown"
-    elif os_name == "windows":
-        os_version = platform.release()
-    elif os_name == "linux":
-        try:
-            out = subprocess.check_output(["lsb_release", "-ds"], text=True).strip().lower()
-            if "ubuntu" in out:
-                os_name = "ubuntu"
-                match = re.search(r"(\d+\.\d+)", out)
-                os_version = match.group(1) if match else "Unknown"
-            else:
-                os_name = "linux"
-                match = re.search(r"(\d+\.\d+)", out)
-                os_version = match.group(1) if match else "Unknown"
-        except Exception:
-            os_name = "linux"
-            try:
-                with open("/etc/os-release") as f:
-                    for line in f:
-                        if line.startswith("VERSION_ID"):
-                            os_version = line.split("=")[1].strip().strip('"')
-                            break
-            except FileNotFoundError:
-                os_version = "Unknown"
-
-    match = re.search(r"(\d+\.\d+|\d+)", os_version)
-    if match:
-        os_version = match.group(1)
+    os_name, os_version, host_arch = _detected_host_platform()
 
     # ──────────────────────────────────────────────
     # Compatibility checks
@@ -1214,16 +1304,19 @@ def _is_platform_compatible(metadata: dict, force: bool = False) -> bool:
 
         # 2️⃣ OS match (mac, ubuntu, linux, windows)
         supported_oses = [o.lower() for o in platform_entry.get("os", [])]
-        if os_name not in supported_oses:
-            if not (os_name == "ubuntu" and "linux" in supported_oses):
-                continue
+        if not _host_os_matches(os_name, supported_oses):
+            continue
 
-        # 3️⃣ Version match
-        versions_dict = platform_entry.get("versions", {})
-        supported_versions = (
-            versions_dict.get(os_name)
-            or (versions_dict.get("linux") if os_name == "ubuntu" else [])
-        )
+        # 3️⃣ Architecture match
+        if not _host_arch_matches(platform_entry, host_arch):
+            click.echo(
+                f"❌ Host architecture {host_arch or 'unknown'} is not supported. "
+                f"Allowed: {platform_entry.get('arch')}"
+            )
+            continue
+
+        # 4️⃣ Version match
+        supported_versions = _host_versions_for_os(platform_entry, os_name)
 
         if supported_versions:
             ok = False
@@ -1248,11 +1341,12 @@ def _is_platform_compatible(metadata: dict, force: bool = False) -> bool:
 
     click.secho(
         f"❌ Current environment [{env_type}:{env_subtype}] "
-        f"({os_name} {os_version}) is not compatible with this package.", fg='red'
+        f"({os_name} {os_version} {host_arch}) is not compatible with this package.", fg='red'
     )
     _print_compatible_platforms(platforms)
     if not force:
         exit(1)
+    return False
 
 
 def _print_post_install_message(metadata: Dict):
@@ -1413,7 +1507,15 @@ def _resolve_github_metadata_url(gh_ref: str) -> Tuple[str, str]:
     except Exception as e:
         raise RuntimeError(f"Failed to resolve GitHub metadata URL {gh_ref}: {e}")
 
-def install_from_metadata(metadata_url: str, internal: bool, install_dir: str = '.', force: bool = False):
+def install_from_metadata(
+    metadata_url: str,
+    internal: bool,
+    install_dir: str = '.',
+    force: bool = False,
+    command_name: str = "sima-cli install",
+):
+    _ensure_install_dir_writable(install_dir, command_name=command_name)
+
     try:
         tag = None
 

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/install/metadata_validator.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from sima_cli.install.compatibility import (
     VALID_OS,
     VALID_PLATFORM_TYPES,
+    normalize_host_arch,
     normalize_exact_version,
     validate_version_spec,
 )
@@ -85,6 +86,45 @@ def validate_metadata(data: dict):
                         f"Invalid OS '{os_value}' in platform entry {i}. Supported: {VALID_OS}"
                     )
 
+            if "versions" in platform:
+                versions = platform["versions"]
+                if not isinstance(versions, dict):
+                    raise MetadataValidationError(f"'versions' must be an object for host in entry {i}")
+                for os_key, specs in versions.items():
+                    if not isinstance(os_key, str) or os_key.lower() not in VALID_OS:
+                        raise MetadataValidationError(
+                            f"Invalid OS '{os_key}' in host versions for platform entry {i}. Supported: {VALID_OS}"
+                        )
+                    if os_key.lower() not in [str(value).lower() for value in platform["os"]]:
+                        raise MetadataValidationError(
+                            f"Host versions key '{os_key}' must also be listed in 'os' for platform entry {i}"
+                        )
+                    if not isinstance(specs, list) or not specs:
+                        raise MetadataValidationError(
+                            f"'versions.{os_key}' must be a non-empty list in platform entry {i}"
+                        )
+                    for spec in specs:
+                        if not isinstance(spec, str):
+                            raise MetadataValidationError(
+                                f"'versions.{os_key}' values must be strings in platform entry {i}"
+                            )
+                        try:
+                            validate_version_spec(spec)
+                        except ValueError as exc:
+                            raise MetadataValidationError(
+                                f"Invalid host version spec for '{os_key}' in entry {i}: {exc}"
+                            )
+
+            if "arch" in platform:
+                arches = platform["arch"]
+                if not isinstance(arches, list) or not arches:
+                    raise MetadataValidationError(f"'arch' must be a non-empty list for host in entry {i}")
+                for arch in arches:
+                    try:
+                        normalize_host_arch(arch)
+                    except ValueError as exc:
+                        raise MetadataValidationError(f"Invalid host architecture in entry {i}: {exc}")
+
         if platform["type"] == "palette" and "version" in platform:
             if not isinstance(platform["version"], str):
                 raise MetadataValidationError(f"'version' must be a string for palette in entry {i}")

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/install/package_builder.py

@@ -246,6 +246,7 @@ def build_metadata(
     exclude: Optional[Sequence[str]] = None,
     download_compatible_files_only: bool = False,
     host_platforms: Optional[Sequence[str]] = None,
+    host_arches: Optional[Sequence[str]] = None,
     board_platforms: Optional[Sequence[str]] = None,
     palette_platform: Optional[str] = None,
 ) -> Dict:
@@ -279,6 +280,7 @@ def build_metadata(
         "description": resolved_description or "",
         "platforms": build_platform_specs(
             host_platforms=host_platforms,
+            host_arches=host_arches,
             board_platforms=board_platforms,
             palette_platform=palette_platform,
         ),

{sima_cli-2.1.11 → sima_cli-2.1.12}/sima_cli/install/registry.py

@@ -135,10 +135,19 @@ def show_metadata(name, version):
     "--host-platform",
     multiple=True,
     help=(
-        "Host OS compatibility as a comma-separated list. Supported values: "
+        "Host OS compatibility as OS[,OS...][@VERSION_SPEC], for example "
+        "linux, ubuntu@==24.04, or ubuntu@>=22.04,<=24.04. Supported OS values: "
         "linux, ubuntu, mac, windows. May be repeated."
     ),
 )
+@click.option(
+    "--host-arch",
+    multiple=True,
+    help=(
+        "Host CPU architecture compatibility as ARCH[,ARCH...], for example amd64 or arm64. "
+        "Aliases x86_64 and aarch64 are normalized. Requires --host-platform."
+    ),
+)
 @click.option(
     "--board-platform",
     multiple=True,
@@ -168,6 +177,7 @@ def build_package_metadata(
     variant,
     download_compatible_files_only,
     host_platform,
+    host_arch,
     board_platform,
     palette_platform,
 ):
@@ -185,6 +195,7 @@ def build_package_metadata(
             exclude=exclude,
             download_compatible_files_only=download_compatible_files_only,
             host_platforms=host_platform,
+            host_arches=host_arch,
             board_platforms=board_platform,
             palette_platform=palette_platform,
         )