vuer-cli 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

vuer_cli/__init__.py

@@ -0,0 +1,20 @@
+"""Vuer CLI - Environment Manager for Vuer Hub."""
+
+from .add import Add
+from .envs_publish import EnvsPublish, Hub
+from .envs_pull import EnvsPull
+from .main import entrypoint
+from .remove import Remove
+from .sync import Sync
+from .upgrade import Upgrade
+
+__all__ = [
+    "entrypoint",
+    "Hub",
+    "Sync",
+    "Add",
+    "Remove",
+    "Upgrade",
+    "EnvsPublish",
+    "EnvsPull",
+]

vuer_cli/add.py

@@ -0,0 +1,93 @@
+"""Add command - add an environment spec to environment.json then sync."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import json
+
+from .sync import Sync, read_environments_lock
+from .utils import print_error, parse_env_spec, normalize_env_spec
+
+
+# Use shared parser from utils; legacy '@' syntax is not supported anymore.
+
+
+@dataclass
+class Add:
+    """Add an environment to environment.json and run `vuer sync`.
+
+    Example:
+        vuer add some-environment/v1.2.3
+    """
+
+    # NOTE: We keep these fields for params-proto compatibility, but the primary
+    # way to call this command is positional: `vuer add name@version`.
+    env: str = ""  # Environment spec to add, e.g. "some-environment/v1.2.3"
+    name: Optional[str] = None  # Unused in current workflow
+    version: str = "latest"  # Unused in current workflow
+
+    def __call__(self) -> int:
+        """Execute add command."""
+        try:
+            env_spec = self.env
+            if not env_spec:
+                # If env is empty, params-proto likely didn't map the positional arg;
+                # treat this as a usage error.
+                raise ValueError(
+                    "Missing environment spec. Usage: vuer add some-environment/v1.2.3"
+                )
+
+            name, version = parse_env_spec(env_spec)
+            env_spec_normalized = normalize_env_spec(f"{name}/{version}")
+
+            cwd = Path.cwd()
+            lock_path = cwd / "environments-lock.yaml"
+
+            # Step 2: Check if already present in environments-lock.yaml
+            if lock_path.exists():
+                existing_deps = read_environments_lock(lock_path)
+                if env_spec_normalized in existing_deps:
+                    print(f"[INFO] Environment {env_spec_normalized} already present in {lock_path}")
+                    return 0
+
+            # Step 3: Ensure environment.json has this dependency, then run sync
+            env_json_path = cwd / "environment.json"
+            if env_json_path.exists():
+                with env_json_path.open("r", encoding="utf-8") as f:
+                    try:
+                        data = json.load(f)
+                    except json.JSONDecodeError as e:
+                        raise ValueError(
+                            f"Invalid environment.json: {e}"
+                        ) from e
+            else:
+                data = {}
+
+            deps = data.get("dependencies")
+            if deps is None:
+                deps = {}
+            if not isinstance(deps, dict):
+                raise ValueError(
+                    "environment.json 'dependencies' field must be an object"
+                )
+
+            # Add or update the dependency
+            deps[name] = version
+            data["dependencies"] = deps
+
+            with env_json_path.open("w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+                f.write("\n")
+
+            print(
+                f"[INFO] Added {env_spec_normalized} to environment.json dependencies. Running sync..."
+            )
+            return Sync()()
+
+        except (FileNotFoundError, ValueError, RuntimeError) as e:
+            print_error(str(e))
+            return 1
+        except Exception as e:
+            print_error(f"Unexpected error: {e}")
+            return 1

vuer_cli/envs_publish.py

@@ -0,0 +1,371 @@
+"""EnvsPublish command - publish an environment version (npm-style workflow)."""
+
+import json
+import tarfile
+import tempfile
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List
+
+from params_proto import EnvVar, proto
+
+from .utils import is_dry_run, print_error, spinner, normalize_env_spec
+
+
+# -- Configuration with environment variable defaults --
+
+@proto.prefix
+class Hub:
+    """Vuer Hub connection settings."""
+
+    url: str = EnvVar("VUER_HUB_URL", default="")  # Base URL of the Vuer Hub API
+    auth_token: str = EnvVar("VUER_AUTH_TOKEN", default="")  # JWT token for authentication
+
+
+# -- Subcommand dataclass --
+
+@dataclass
+class EnvsPublish:
+    """Publish environment to registry (npm-style).
+
+    Reads environment.json, creates tgz archive, and uploads to the hub.
+    """
+
+    directory: str = "."  # Directory containing environment.json
+    timeout: int = 300  # Request timeout in seconds
+    tag: str = "latest"  # Version tag
+    dry_run: bool = False  # Simulate without uploading
+
+    def __call__(self) -> int:
+        """Execute envs-publish command."""
+        try:
+            dry_run = self.dry_run or is_dry_run()
+
+            if not dry_run:
+                if not Hub.url:
+                    raise RuntimeError(
+                        "Missing VUER_HUB_URL. Please set the VUER_HUB_URL environment variable "
+                        "or pass --hub.url on the command line."
+                    )
+                if not Hub.auth_token:
+                    raise RuntimeError(
+                        "Missing VUER_AUTH_TOKEN. Please set the VUER_AUTH_TOKEN environment "
+                        "variable or pass --hub.auth-token on the command line."
+                    )
+
+            print(f"[INFO] Reading environment.json from {self.directory}...")
+            metadata, envs_metadata = parse_environments_json(self.directory)
+            print(f"[INFO] Found package: {metadata['name']}/{metadata['version']}")
+
+            # Validate dependencies if present
+            dependencies = extract_dependencies(envs_metadata)
+            if dependencies:
+                print(f"[INFO] Validating {len(dependencies)} dependencies...")
+                validate_dependencies(dependencies, dry_run, Hub.url, Hub.auth_token)
+                print("[INFO] All dependencies are valid.")
+            else:
+                print("[INFO] No dependencies to validate.")
+
+            print("[INFO] Creating tgz archive...")
+            archive_path = create_tgz_archive(self.directory, metadata)
+            print(f"[INFO] Archive created: {archive_path}")
+
+            publish_to_registry(
+                archive_path=archive_path,
+                metadata=metadata,
+                envs_metadata=envs_metadata,
+                hub_url=Hub.url,
+                auth_token=Hub.auth_token,
+                timeout=self.timeout,
+                dry_run=dry_run,
+            )
+
+            return 0
+        except FileNotFoundError as e:
+            print_error(str(e))
+            return 1
+        except ValueError as e:
+            print_error(str(e))
+            return 1
+        except RuntimeError as e:
+            # RuntimeError from validate_dependencies already prints error message
+            # Only print if it wasn't already printed
+            if "Dependency validation failed" not in str(e):
+                print_error(str(e))
+            return 1
+        except Exception as e:
+            print_error(f"Unexpected error: {e}")
+            return 1
+
+
+# -- Helper functions --
+
+def parse_environments_json(directory: str) -> tuple[Dict[str, Any], Dict[str, Any]]:
+    """Parse environment.json and extract metadata plus full content.
+
+    Returns:
+        (metadata, full_data)
+    """
+    envs_path = Path(directory) / "environment.json"
+    if not envs_path.exists():
+        raise FileNotFoundError(f"environment.json not found in {directory}")
+
+    try:
+        with envs_path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid environment.json: {e}") from e
+
+    metadata = {
+        "name": data.get("name", ""),
+        "version": data.get("version", ""),
+        "description": data.get("description", ""),
+        "visibility": data.get("visibility", "PUBLIC"),
+        "env_type": data.get("env-type", "") or data.get("env_type", ""),
+    }
+
+    if not metadata["name"]:
+        raise ValueError("environment.json must contain 'name' field")
+    if not metadata["version"]:
+        raise ValueError("environment.json must contain 'version' field")
+
+    return metadata, data
+
+
+def extract_dependencies(envs_metadata: Dict[str, Any]) -> List[str]:
+    """Extract dependencies from environment.json and convert to list format.
+
+    Args:
+        envs_metadata: Full environment.json content
+
+    Returns:
+        List of dependency specs like ["some-dependency/^1.2.3", ...]
+        Returns empty list if no dependencies or dependencies is empty.
+    """
+    deps_dict = envs_metadata.get("dependencies", {})
+    if not deps_dict or not isinstance(deps_dict, dict):
+        return []
+
+    dependencies = []
+    for name, version_spec in deps_dict.items():
+        if not isinstance(version_spec, str):
+            version_spec = str(version_spec)
+        dependencies.append(normalize_env_spec(f"{name}/{version_spec}"))
+
+    return dependencies
+
+
+def validate_dependencies(
+    dependencies: List[str],
+    dry_run: bool,
+    hub_url: str,
+    auth_token: str,
+) -> None:
+    """Validate dependencies with backend API.
+
+    Args:
+        dependencies: List of dependency specs like ["name/version", ...]
+        dry_run: Whether to run in dry-run mode
+        hub_url: Vuer Hub base URL
+        auth_token: Authentication token
+
+    Raises:
+        RuntimeError: If validation fails (non-200 status or error in response)
+    """
+    if dry_run or is_dry_run():
+        print("[INFO] (dry-run) Validating dependencies (simulated)...")
+        return
+
+    if not hub_url:
+        raise RuntimeError(
+            "Missing VUER_HUB_URL. Cannot validate dependencies without hub URL."
+        )
+
+    import requests
+
+    url = f"{hub_url.rstrip('/')}/environments/dependencies"
+    headers = {}
+    if auth_token:
+        headers["Authorization"] = f"Bearer {auth_token}"
+    headers["Content-Type"] = "application/json"
+
+    payload = {"name_versionId_list": dependencies}
+
+    try:
+        response = requests.post(url, json=payload, headers=headers, timeout=300)
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"Failed to validate dependencies: {e}") from e
+
+    status = response.status_code
+
+    # Handle non-200 status codes
+    if status != 200:
+        error_msg = ""
+        try:
+            data = response.json()
+            if isinstance(data, dict):
+                error_msg = data.get("error") or data.get("message", "")
+                if not error_msg:
+                    error_msg = json.dumps(data, ensure_ascii=False)
+            else:
+                error_msg = json.dumps(data, ensure_ascii=False)
+        except Exception:
+            text = (response.text or "").strip()
+            error_msg = text if text else "Unknown error"
+
+        if error_msg:
+            print_error(f"Dependency validation failed ({status}): {error_msg}")
+        else:
+            print_error(f"Dependency validation failed ({status})")
+        raise RuntimeError(f"Dependency validation failed with status {status}")
+
+    # Status 200: check for error field in response body
+    try:
+        data = response.json()
+        if isinstance(data, dict) and "error" in data:
+            error_msg = data["error"]
+            print_error(f"Dependency validation failed: {error_msg}")
+            raise RuntimeError(f"Dependency validation failed: {error_msg}")
+    except (json.JSONDecodeError, ValueError):
+        # Response is not JSON or doesn't have error field, assume success
+        pass
+
+
+def create_tgz_archive(directory: str, metadata: Dict[str, Any]) -> str:
+    """Create a tgz archive from environment files."""
+    archive_name = f"{metadata['name']}-{metadata['version']}.tgz"
+    temp_dir = Path(tempfile.gettempdir())
+    archive_path = str(temp_dir / archive_name)
+
+    directory_path = Path(directory).resolve()
+
+    with tarfile.open(archive_path, "w:gz") as tar:
+        for file_path in directory_path.rglob("*"):
+            if file_path.is_file():
+                arcname = file_path.relative_to(directory_path)
+                tar.add(file_path, arcname=arcname)
+
+    return archive_path
+
+
+def upload_with_progress(archive_path: str, metadata: Dict[str, Any], timeout: int) -> None:
+    """Simulate an upload in dry-run mode."""
+    file_path = Path(archive_path)
+    total_size = file_path.stat().st_size
+    print(f"[INFO] (dry-run) Uploading {file_path.name} ({total_size} bytes)...")
+    time.sleep(min(2.0, max(0.1, total_size / (10 * 1024 * 1024))))
+
+
+def publish_to_registry(
+    archive_path: str,
+    metadata: Dict[str, Any],
+    envs_metadata: Dict[str, Any],
+    hub_url: str,
+    auth_token: str,
+    timeout: int,
+    dry_run: bool,
+) -> None:
+    """Publish package to registry via API."""
+    print(f"[INFO] Publishing {metadata['name']}/{metadata['version']} to registry...")
+    print(f"[INFO] Archive: {archive_path}")
+    print(f"[INFO] Metadata: {json.dumps(metadata, indent=2)}")
+    print(f"[INFO] environment.json: {json.dumps(envs_metadata, indent=2)}")
+    print(f"[INFO] Hub URL: {hub_url}")
+    print(f"[INFO] Timeout: {timeout}s")
+
+    if dry_run or is_dry_run():
+        upload_with_progress(archive_path, metadata, timeout)
+        print(f"[SUCCESS] (dry-run) Published {metadata['name']}/{metadata['version']} (no network call).")
+        return
+
+    # Import requests lazily to avoid SSL/cert loading in restricted envs.
+    import requests
+
+    url = f"{hub_url.rstrip('/')}/environments/upload"
+    file_path = Path(archive_path)
+
+    with file_path.open("rb") as f:
+        files = {
+            "package": (file_path.name, f, "application/octet-stream"),
+        }
+        data = {
+            "name": str(metadata["name"]),
+            "versionId": str(metadata["version"]),
+            "description": str(metadata.get("description", "")),
+            "type": str(metadata.get("env_type", "")),
+            "visibility": str(metadata.get("visibility", "PUBLIC")),
+        }
+        # Send full environment.json content as metadata field.
+        data["metadata"] = json.dumps(envs_metadata, ensure_ascii=False)
+
+        headers = {}
+        if auth_token:
+            headers["Authorization"] = f"Bearer {auth_token}"
+
+        stop_event = threading.Event()
+        spinner_thread = threading.Thread(
+            target=spinner,
+            args=(f"[INFO] Uploading {file_path.name} ", stop_event),
+            daemon=True,
+        )
+        spinner_thread.start()
+        try:
+            response = requests.post(
+                url,
+                data=data,
+                files=files,
+                headers=headers,
+                timeout=timeout,
+            )
+        finally:
+            stop_event.set()
+            spinner_thread.join()
+
+    status = response.status_code
+    text = (response.text or "").strip()
+
+    if status >= 300:
+        inline_msg = ""
+        try:
+            data = response.json()
+            if isinstance(data, dict):
+                msg = data.get("message")
+                err = data.get("error")
+                if msg:
+                    inline_msg = str(msg)
+                elif err:
+                    inline_msg = str(err)
+                else:
+                    inline_msg = json.dumps(data, ensure_ascii=False)
+            else:
+                inline_msg = json.dumps(data, ensure_ascii=False)
+        except Exception:
+            inline_msg = text
+
+        inline_msg = (inline_msg or "").strip()
+        if inline_msg:
+            raise RuntimeError(f"Publish failed ({status}): {inline_msg}")
+        raise RuntimeError(f"Publish failed ({status})")
+
+    env_id = None
+    env_name = metadata.get("name")
+    env_version = metadata.get("version")
+    try:
+        payload = response.json()
+        env = payload.get("environment", payload) if isinstance(payload, dict) else {}
+        env_id = env.get("environmentId") or env.get("id")
+        env_name = env.get("name", env_name)
+        env_version = env.get("versionId", env_version)
+    except Exception:
+        pass
+
+    print("\n=== Publish Success ===")
+    if env_id:
+        print(f"ID        : {env_id}")
+    print(f"Name      : {env_name}")
+    print(f"Version   : {env_version}")
+    visibility = metadata.get("visibility", "PUBLIC")
+    print(f"Visibility: {visibility}")
+

vuer_cli/envs_pull.py

@@ -0,0 +1,206 @@
+"""EnvsPull command - download an environment by ID."""
+
+import tarfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, Optional
+
+from tqdm import tqdm
+
+from .envs_publish import Hub
+from .utils import is_dry_run, print_error, parse_env_spec
+
+
+# -- Subcommand dataclass --
+
+@dataclass
+class EnvsPull:
+    """Download an environment from the registry by ID or name/version."""
+
+    flag: str = ""  # Environment identifier (ID or name/version) to download
+    output: str = "downloads"  # Destination directory
+    filename: Optional[str] = None  # Override saved filename
+    version: Optional[str] = None  # Specific version to download
+    timeout: int = 300  # Request timeout in seconds
+    skip_progress: bool = False  # Disable progress bar
+
+    def __call__(self) -> int:
+        """Execute envs-pull command."""
+        try:
+            if not is_dry_run():
+                if not Hub.url:
+                    raise RuntimeError(
+                        "Missing VUER_HUB_URL. Please set the VUER_HUB_URL environment variable "
+                        "or pass --hub.url on the command line."
+                    )
+                if not Hub.auth_token:
+                    raise RuntimeError(
+                        "Missing VUER_AUTH_TOKEN. Please set the VUER_AUTH_TOKEN environment "
+                        "variable or pass --hub.auth-token on the command line."
+                    )
+
+            print(f"[INFO] Pulling environment {self.flag} ...")
+            pull_from_registry(
+                env_flag=self.flag,
+                output_dir=self.output,
+                filename=self.filename,
+                version=self.version,
+                timeout=self.timeout,
+                skip_progress=self.skip_progress,
+            )
+            return 0
+        except Exception as e:
+            print_error(str(e))
+            return 1
+
+
+# -- Helper functions --
+
+def download_with_progress(
+    destination: Path,
+    total_size: int,
+    stream: Iterable[bytes],
+    skip_progress: bool,
+) -> None:
+    """Write streamed bytes to destination with an optional progress bar."""
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    if skip_progress:
+        with destination.open("wb") as f:
+            for chunk in stream:
+                f.write(chunk)
+        return
+
+    with destination.open("wb") as f, tqdm(
+        total=total_size or None,
+        unit="B",
+        unit_scale=True,
+        unit_divisor=1024,
+        desc=f"Downloading {destination.name}",
+        ncols=100,
+    ) as pbar:
+        for chunk in stream:
+            f.write(chunk)
+            pbar.update(len(chunk))
+
+
+def extract_filename_from_headers(headers: Dict[str, str], default_name: str) -> str:
+    """Extract filename from Content-Disposition header (RFC 5987 style)."""
+    content_disposition = headers.get("Content-Disposition", "")
+    if not content_disposition:
+        return default_name
+
+    if "filename*=" in content_disposition:
+        part = content_disposition.split("filename*=")[-1].strip()
+        if part.lower().startswith("utf-8''"):
+            encoded = part[7:]
+        else:
+            encoded = part
+        encoded = encoded.split(";")[0].strip().strip('"')
+        try:
+            from urllib.parse import unquote
+            candidate = unquote(encoded)
+            if candidate:
+                return candidate
+        except Exception:
+            pass
+
+    if "filename=" in content_disposition:
+        candidate = content_disposition.split("filename=")[-1].strip().strip('"')
+        candidate = candidate.split(";")[0].strip()
+        if candidate:
+            return candidate
+
+    return default_name
+
+
+def pull_from_registry(
+    env_flag: str,
+    output_dir: str,
+    filename: Optional[str],
+    version: Optional[str],
+    timeout: int,
+    skip_progress: bool,
+) -> Path:
+    """Download environment by ID or name/version and extract archive into a directory."""
+    hub_url = Hub.url
+    auth_token = Hub.auth_token
+    headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else {}
+
+    # New API: /api/environments/download?environment_id=<id or name@version>
+    from urllib.parse import urlencode
+
+    base_url = f"{hub_url.rstrip('/')}/environments/download"
+    query = urlencode({"environment_id": env_flag})
+    url = f"{base_url}?{query}"
+
+    output_dir_path = Path(output_dir).expanduser().resolve()
+    output_dir_path.mkdir(parents=True, exist_ok=True)
+
+    if is_dry_run():
+        # If env_flag is a name/version, create nested dirs name/version
+        try:
+            name, version = parse_env_spec(env_flag)
+            env_dir = output_dir_path / name / version
+        except Exception:
+            env_dir = output_dir_path / str(env_flag)
+        env_dir.mkdir(parents=True, exist_ok=True)
+        (env_dir / "README.txt").write_text("Dry-run environment content\n")
+        print(f"[SUCCESS] (dry-run) Downloaded to {env_dir}")
+        return env_dir
+
+    # Lazy import requests to avoid SSL/cert issues in dry-run/tests.
+    import requests
+
+    with requests.get(url, headers=headers, stream=True, timeout=timeout) as resp:
+        resp.raise_for_status()
+        total_size = int(resp.headers.get("Content-Length", 0))
+        # Use filesystem-safe archive name when env_flag contains '/'
+        # When env_flag is name/version, use name-version for filename
+        try:
+            name, version = parse_env_spec(env_flag)
+            safe_name = f"{name}-{version}"
+        except Exception:
+            safe_name = str(env_flag)
+        default_archive_name = f"{safe_name}.tgz"
+        archive_name = filename or extract_filename_from_headers(resp.headers, default_archive_name)
+        archive_path = output_dir_path / archive_name
+
+        stream = (chunk for chunk in resp.iter_content(chunk_size=1024 * 512) if chunk)
+        download_with_progress(archive_path, total_size, stream, skip_progress)
+
+    # Derive target directory name from archive filename
+    suffixes = "".join(archive_path.suffixes)
+    if suffixes.endswith(".tar.gz"):
+        base_name = archive_path.name[: -len(".tar.gz")]
+    elif suffixes.endswith(".tgz"):
+        base_name = archive_path.name[: -len(".tgz")]
+    elif suffixes.endswith(".tar"):
+        base_name = archive_path.name[: -len(".tar")]
+    else:
+        base_name = archive_path.stem
+
+    # Prefer nested directory when env_flag is parseable
+    try:
+        name, version = parse_env_spec(env_flag)
+        env_dir = output_dir_path / name / version
+    except Exception:
+        env_dir = output_dir_path / base_name
+    env_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        if tarfile.is_tarfile(archive_path):
+            with tarfile.open(archive_path, "r:*") as tar:
+                tar.extractall(env_dir)
+            archive_path.unlink(missing_ok=True)
+            print(f"[SUCCESS] Downloaded and extracted to {env_dir}")
+        else:
+            print(f"[WARN] Downloaded file is not a tar archive, kept as {archive_path}")
+            env_dir = archive_path
+    except Exception as e:
+        print_error(f"Failed to extract archive: {e}")
+        env_dir = archive_path
+
+    return env_dir
+
+