sima-cli 2.1.6__tar.gz → 2.1.7__tar.gz

{sima_cli-2.1.6/sima_cli.egg-info → sima_cli-2.1.7}/PKG-INFO

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

{sima_cli-2.1.6 → sima_cli-2.1.7}/pyproject.toml

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

{sima_cli-2.1.6 → sima_cli-2.1.7}/sima_cli/__version__.py

@@ -1,2 +1,2 @@
 # sima_cli/__version__.py
-__version__ = "2.1.6"
+__version__ = "2.1.7"

{sima_cli-2.1.6 → sima_cli-2.1.7}/sima_cli/cli.py

@@ -30,6 +30,7 @@ from sima_cli.install.registry import register_packages_commands
 from sima_cli.upgrade.selfupdate import register_selfupdate_command
 from sima_cli.playbooks import register_playbook_commands
 from sima_cli.vulcan import register_vulcan_commands
+from sima_cli.vulcan.commands import ENV_BASE_URLS, install_vulcan_package
 
 def _configure_stdio_errors() -> None:
     for stream in (getattr(sys, "stdout", None), getattr(sys, "stderr", None)):
@@ -504,7 +505,31 @@ ALL_COMPONENTS = SDK_DEPENDENT_COMPONENTS | SDK_INDEPENDENT_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.option("-t", "--tag", help="Tag of the package. With --vulcan, metadata variant type such as minimum.")
+@click.option("--vulcan", "use_vulcan", is_flag=True, help="Install from Vulcan artifacts using the Vulcan package resolver.")
+@click.option(
+    "--env",
+    "vulcan_environment",
+    type=click.Choice(sorted(ENV_BASE_URLS), case_sensitive=False),
+    default=None,
+    help="Vulcan artifact environment. Used with --vulcan. Defaults to production.",
+)
+@click.option(
+    "--base-url",
+    "vulcan_base_url",
+    default=None,
+    envvar="SIMA_VULCAN_BASE_URL",
+    help="Override the Vulcan artifact base URL. Used with --vulcan.",
+)
+@click.option(
+    "-d",
+    "--install-dir",
+    default=".",
+    show_default=True,
+    type=click.Path(file_okay=False, dir_okay=True, path_type=str),
+    help="Directory where Vulcan package resources are downloaded and installed. Used with --vulcan.",
+)
+@click.option("--json", "json_output", is_flag=True, help="With --vulcan, print resolved metadata URL and exit.")
 @click.option(
     "-f",
     "--force",
@@ -513,7 +538,7 @@ ALL_COMPONENTS = SDK_DEPENDENT_COMPONENTS | SDK_INDEPENDENT_COMPONENTS
     help="Force installation even if compatibility checks fail.",
 )
 @click.pass_context
-def install_cmd(ctx, component, version, mirror, tag, force):
+def install_cmd(ctx, component, version, mirror, tag, use_vulcan, vulcan_environment, vulcan_base_url, install_dir, json_output, force):
     """
     Install SiMa packages.
 
@@ -548,12 +573,29 @@ def install_cmd(ctx, component, version, mirror, tag, force):
     """
     internal = ctx.obj.get("internal", False)
 
+    if use_vulcan:
+        if mirror:
+            raise click.ClickException("--mirror cannot be used with --vulcan.")
+        if not component:
+            raise click.ClickException("You must specify a Vulcan target when using --vulcan.")
+        install_vulcan_package(
+            target=component,
+            environment=vulcan_environment or "production",
+            base_url=vulcan_base_url,
+            package_type=tag,
+            install_dir=install_dir,
+            force=force,
+            json_output=json_output,
+        )
+        return None
+
     # 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}")
-        return install_from_metadata(metadata_url=mirror, internal=internal, force=force)
+        install_from_metadata(metadata_url=mirror, internal=internal, force=force)
+        return None
 
     # No component and no metadata: error
     if not component:
@@ -562,11 +604,13 @@ def install_cmd(ctx, component, version, mirror, tag, force):
 
     # if user specified gh: as component, treat it the same as -m
     if component.startswith("gh:"):
-        return install_from_metadata(metadata_url=component, internal=False, force=force)
+        install_from_metadata(metadata_url=component, internal=False, force=force)
+        return None
     
     # if the user specified cr: or ghcr: as component, install from container registry
     if component.startswith("cr:") or component.startswith("ghcr:"):
-        return install_from_cr(resource_spec=component, internal=internal)
+        install_from_cr(resource_spec=component, internal=internal)
+        return None
 
     version = resolve_version(version)
 
@@ -601,6 +645,7 @@ def install_cmd(ctx, component, version, mirror, tag, force):
             ctx.exit(1)
 
     click.echo("✅ Installation complete.")
+    return None
 
 
 # ----------------------

{sima_cli-2.1.6 → sima_cli-2.1.7}/sima_cli/install/metadata_installer.py

@@ -936,6 +936,10 @@ def _is_platform_compatible(metadata: dict, force: bool = False) -> bool:
     platforms = metadata.get("platforms", [])
     board_ver, _ = get_sima_build_version()
 
+    if not platforms:
+        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"

sima_cli-2.1.7/sima_cli/install/package_builder.py

@@ -0,0 +1,304 @@
+import datetime
+import hashlib
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import requests
+
+
+METADATA_FILENAME = "metadata.json"
+DEFAULT_POST_MESSAGE = "[bold]Package installed successfully.[/bold]\n"
+
+
+def _run_git(args: List[str], cwd: Path) -> Optional[str]:
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=str(cwd),
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    return result.stdout.strip()
+
+
+def _git_root(search_dir: Path) -> Optional[Path]:
+    output = _run_git(["rev-parse", "--show-toplevel"], search_dir)
+    if not output:
+        return None
+    return Path(output).resolve()
+
+
+def _github_repo_from_remote(remote_url: str) -> Optional[Tuple[str, str]]:
+    value = remote_url.strip()
+    if value.endswith(".git"):
+        value = value[:-4]
+
+    if value.startswith("git@github.com:"):
+        value = value[len("git@github.com:"):]
+    elif value.startswith("https://github.com/"):
+        value = value[len("https://github.com/"):]
+    elif value.startswith("http://github.com/"):
+        value = value[len("http://github.com/"):]
+    else:
+        return None
+
+    parts = value.split("/")
+    if len(parts) != 2 or not parts[0] or not parts[1]:
+        return None
+    return parts[0], parts[1]
+
+
+def resolve_git_context(artifacts_folder: Path) -> Tuple[Optional[Path], Optional[Tuple[str, str]]]:
+    for search_dir in (Path.cwd(), artifacts_folder):
+        root = _git_root(search_dir)
+        if not root:
+            continue
+        remote = _run_git(["remote", "get-url", "origin"], root) or ""
+        return root, _github_repo_from_remote(remote)
+    return None, None
+
+
+def default_package_name(artifacts_folder: Path) -> str:
+    git_root, github_repo = resolve_git_context(artifacts_folder)
+    if github_repo:
+        owner, repo = github_repo
+        return "gh:{}/{}".format(owner, repo)
+    if git_root:
+        return git_root.name
+    return Path.cwd().name
+
+
+def default_version(artifacts_folder: Path) -> str:
+    git_root, _github_repo = resolve_git_context(artifacts_folder)
+    if git_root:
+        tag = _run_git(["describe", "--tags", "--exact-match"], git_root)
+        if tag:
+            return tag
+        commit = _run_git(["rev-parse", "--short", "HEAD"], git_root)
+        if commit:
+            return commit
+    return datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+
+
+def github_repo_description(artifacts_folder: Path) -> str:
+    _git_root, github_repo = resolve_git_context(artifacts_folder)
+    if not github_repo:
+        return ""
+
+    owner, repo = github_repo
+    headers = {"Accept": "application/vnd.github+json"}
+    token = os.getenv("GITHUB_TOKEN")
+    if token:
+        headers["Authorization"] = "Bearer {}".format(token)
+
+    try:
+        response = requests.get(
+            "https://api.github.com/repos/{}/{}".format(owner, repo),
+            headers=headers,
+            timeout=5,
+        )
+        response.raise_for_status()
+        description = response.json().get("description")
+    except Exception:
+        return ""
+    return description if isinstance(description, str) else ""
+
+
+def _sha256_file(path: Path) -> str:
+    hasher = hashlib.sha256()
+    with path.open("rb") as file_obj:
+        for chunk in iter(lambda: file_obj.read(1024 * 1024), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+
+def _format_size(total_bytes: int) -> str:
+    units = (("GB", 1024 ** 3), ("MB", 1024 ** 2), ("KB", 1024))
+    if total_bytes <= 0:
+        return "0KB"
+    for suffix, factor in units:
+        if total_bytes >= factor:
+            value = total_bytes / factor
+            text = "{:.1f}".format(value).rstrip("0").rstrip(".")
+            return "{}{}".format(text, suffix)
+    return "1KB"
+
+
+def _matches_exclude_pattern(resource: str, patterns: Sequence[str]) -> bool:
+    filename = Path(resource).name
+    return any(pattern and (pattern in resource or pattern in filename) for pattern in patterns)
+
+
+def collect_artifact_resources(
+    artifacts_folder: Path,
+    exclude_patterns: Optional[Sequence[str]] = None,
+) -> Tuple[List[str], Dict[str, Path], int]:
+    resources = []
+    resource_paths = {}
+    total_size = 0
+    normalized_excludes = [pattern.strip() for pattern in (exclude_patterns or []) if pattern.strip()]
+
+    for path in sorted(artifacts_folder.rglob("*")):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(artifacts_folder).as_posix()
+        if rel == METADATA_FILENAME or re.fullmatch(r"metadata-[A-Za-z0-9_.-]+\.json", rel):
+            continue
+        if _matches_exclude_pattern(rel, normalized_excludes):
+            continue
+        resources.append(rel)
+        resource_paths[rel] = path
+        total_size += path.stat().st_size
+
+    return resources, resource_paths, total_size
+
+
+def parse_selectables(selectables: Optional[str]) -> List[Tuple[str, str]]:
+    if not selectables:
+        return []
+
+    parsed = []
+    for raw_item in selectables.split(";"):
+        item = raw_item.strip()
+        if not item:
+            continue
+        if ":" not in item:
+            raise ValueError("selectables entries must use 'name:file' format")
+        name, resource = item.split(":", 1)
+        name = name.strip()
+        resource = resource.strip()
+        if not name or not resource:
+            raise ValueError("selectables entries must include both name and file")
+        parsed.append((name, resource))
+    return parsed
+
+
+def build_selectable_resources(
+    selectable_specs: List[Tuple[str, str]],
+    resource_paths: Dict[str, Path],
+) -> List[Dict[str, str]]:
+    selectable_resources = []
+    seen_resources = set()
+
+    for name, resource in selectable_specs:
+        if resource not in resource_paths:
+            raise ValueError("selectable resource is not in artifacts-folder: {}".format(resource))
+        if resource in seen_resources:
+            raise ValueError("duplicate selectable resource: {}".format(resource))
+        seen_resources.add(resource)
+        selectable_resources.append({
+            "name": name,
+            "url": "",
+            "resource": resource,
+            "checksum": _sha256_file(resource_paths[resource]),
+        })
+
+    return selectable_resources
+
+
+def resolve_install_script(artifacts_folder: Path, install_script: str) -> str:
+    script = install_script.strip()
+    if not script:
+        raise ValueError("install-script cannot be empty")
+
+    candidate_paths = []
+    raw_path = Path(script).expanduser()
+    if raw_path.is_absolute():
+        candidate_paths.append(raw_path)
+    else:
+        candidate_paths.append(artifacts_folder / raw_path)
+        candidate_paths.append(Path.cwd() / raw_path)
+
+    artifacts_root = artifacts_folder.resolve()
+    for candidate in candidate_paths:
+        try:
+            resolved = candidate.resolve()
+        except OSError:
+            continue
+        if not resolved.is_file():
+            continue
+        try:
+            rel = resolved.relative_to(artifacts_root).as_posix()
+        except ValueError:
+            continue
+        return "./{}".format(rel)
+
+    return script
+
+
+def build_metadata(
+    artifacts_folder: Path,
+    name: Optional[str] = None,
+    version: Optional[str] = None,
+    description: Optional[str] = None,
+    install_script: str = "",
+    selectables: Optional[str] = None,
+    exclude: Optional[Sequence[str]] = None,
+) -> Dict:
+    artifacts_folder = artifacts_folder.expanduser().resolve()
+    if not artifacts_folder.is_dir():
+        raise ValueError("artifacts-folder is not a directory: {}".format(artifacts_folder))
+
+    resources, resource_paths, total_size = collect_artifact_resources(artifacts_folder, exclude_patterns=exclude)
+    if not resources:
+        raise ValueError("artifacts-folder does not contain any artifact files")
+
+    selectable_specs = parse_selectables(selectables)
+    selectable_resources = build_selectable_resources(selectable_specs, resource_paths)
+    selectable_resource_names = {entry["resource"] for entry in selectable_resources}
+    resources = [resource for resource in resources if resource not in selectable_resource_names]
+    checksums = {
+        resource: _sha256_file(path)
+        for resource, path in resource_paths.items()
+        if resource not in selectable_resource_names
+    }
+
+    resolved_description = description
+    if resolved_description is None:
+        resolved_description = github_repo_description(artifacts_folder)
+
+    size_text = _format_size(total_size)
+    return {
+        "name": name or default_package_name(artifacts_folder),
+        "version": version or default_version(artifacts_folder),
+        "release": "",
+        "description": resolved_description or "",
+        "platforms": [],
+        "resources": resources,
+        "resources-checksum": checksums,
+        "selectable-resources": selectable_resources,
+        "size": {
+            "download": size_text,
+            "install": size_text,
+        },
+        "installation": {
+            "script": resolve_install_script(artifacts_folder, install_script),
+            "post-message": DEFAULT_POST_MESSAGE,
+        },
+    }
+
+
+def metadata_filename(variant: Optional[str] = None) -> str:
+    if variant is None:
+        return METADATA_FILENAME
+
+    normalized = variant.strip()
+    if not normalized:
+        return METADATA_FILENAME
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", normalized):
+        raise ValueError("variant must contain only letters, numbers, dots, underscores, or hyphens")
+    return "metadata-{}.json".format(normalized)
+
+
+def write_metadata(artifacts_folder: Path, metadata: Dict, variant: Optional[str] = None) -> Path:
+    output_path = artifacts_folder.expanduser().resolve() / metadata_filename(variant)
+    output_path.write_text(json.dumps(metadata, indent=4) + "\n", encoding="utf-8")
+    return output_path

{sima_cli-2.1.6 → sima_cli-2.1.7}/sima_cli/install/registry.py

@@ -19,6 +19,7 @@ import json
 import click
 import datetime
 from pathlib import Path
+from sima_cli.install.package_builder import build_metadata, write_metadata
 from rich.table import Table
 from rich.console import Console
 from rich.syntax import Syntax
@@ -74,6 +75,54 @@ def show_metadata(name, version):
     except ValueError as e:
         Console().print(f"[red]Error:[/red] {e}")
 
+
+@packages.command("build", help="Build package metadata.json from an artifacts folder.")
+@click.argument(
+    "artifacts_folder",
+    metavar="ARTIFACTS_FOLDER",
+    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
+)
+@click.option("--name", help="Package name. Defaults to gh:<org>/<repo> for GitHub repos.")
+@click.option("--version", help="Package version. Defaults to exact git tag or short commit hash.")
+@click.option("--description", help="Package description. Defaults to the GitHub repo description when available.")
+@click.option(
+    "--install-script",
+    required=True,
+    help="Install script file inside ARTIFACTS_FOLDER, or a single-line shell command.",
+)
+@click.option(
+    "--selectables",
+    help="Optional resources in 'name1:file1;name2:file2' format.",
+)
+@click.option(
+    "--exclude",
+    multiple=True,
+    help="Exclude artifact files whose relative path or filename contains this text. May be repeated.",
+)
+@click.option(
+    "--variant",
+    help="Optional metadata variant name. Writes metadata-<variant>.json instead of metadata.json.",
+)
+def build_package_metadata(artifacts_folder, name, version, description, install_script, selectables, exclude, variant):
+    """
+    Generate metadata.json, or metadata-<variant>.json, for sima-cli package installation.
+    """
+    try:
+        metadata = build_metadata(
+            artifacts_folder=artifacts_folder,
+            name=name,
+            version=version,
+            description=description,
+            install_script=install_script,
+            selectables=selectables,
+            exclude=exclude,
+        )
+        output_path = write_metadata(artifacts_folder, metadata, variant=variant)
+    except ValueError as exc:
+        raise click.ClickException(str(exc))
+
+    click.echo(f"✅ Package metadata written to: {output_path}")
+
 # ------------------------------------------------------------------------------------------------------------
 # Register the group to main CLI entrypoint, skip this group if it's running inside the SDK container already
 # ------------------------------------------------------------------------------------------------------------

{sima_cli-2.1.6 → sima_cli-2.1.7}/sima_cli/sdk/commands.py

@@ -38,7 +38,7 @@ console = Console()
 # ------------------------------------------------------------
 # Group Definition
 # ------------------------------------------------------------
-@click.group(hidden=True, context_settings={"ignore_unknown_options": True, "allow_extra_args": True})
+@click.group(context_settings={"ignore_unknown_options": True, "allow_extra_args": True})
 @click.option(
     "-v", "--version",
     "version_filter",