riciplay-cli 1.7.0__py3-none-any.whl

riciplay_cli/__init__.py

@@ -0,0 +1,2 @@
+"""Riciplay CLI — Command-line interface for the Riciplay Security Platform."""
+__version__ = "1.7.0"

riciplay_cli/auto_updater.py

@@ -0,0 +1,250 @@
+"""
+Auto-Updater (Phase F Part 3)
+
+Checks for Riciplay CLI updates from GitHub releases.
+Supports stable/beta/nightly channels. Checks on startup and on-demand.
+Never auto-installs — always requires user confirmation.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import httpx
+from packaging.version import Version, InvalidVersion
+
+logger = logging.getLogger(__name__)
+
+# Default configuration keys
+DEFAULT_UPDATE_ENABLED = True
+DEFAULT_UPDATE_CHANNEL = "stable"
+DEFAULT_UPDATE_CHECK_INTERVAL = 86400  # 24 hours
+
+# GitHub releases API
+GITHUB_API_URL = "https://api.github.com/repos/Zaidux/Riciplay/releases"
+UPDATE_CHECK_TIMEOUT = 10.0  # seconds
+
+
+def _get_current_version() -> str:
+    """Read current version from the riciplay package metadata."""
+    try:
+        from importlib.metadata import version
+        return version("riciplay-cli")
+    except Exception:
+        pass
+
+    # Fallback: try reading from nearby pyproject.toml
+    pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            content = pyproject.read_text(encoding="utf-8")
+            for line in content.split("\n"):
+                stripped = line.strip()
+                if stripped.startswith("version"):
+                    parts = stripped.split("=", 1)
+                    if len(parts) == 2:
+                        return parts[1].strip().strip('"').strip("'")
+        except Exception:
+            pass
+
+    return "0.0.0"
+
+
+def _parse_version(version_str: str) -> Version:
+    """Parse a version string, stripping leading 'v' if present."""
+    clean = version_str.lstrip("v").strip()
+    return Version(clean)
+
+
+class UpdateInfo:
+    """Information about an available update."""
+    def __init__(self, version: str, channel: str, release_notes: str, download_url: str, published_at: str):
+        self.version = version
+        self.channel = channel
+        self.release_notes = release_notes
+        self.download_url = download_url
+        self.published_at = published_at
+
+    @property
+    def is_newer(self) -> bool:
+        try:
+            current = _parse_version(_get_current_version())
+            new = _parse_version(self.version)
+            return new > current
+        except (InvalidVersion, ValueError):
+            return False
+
+
+class AutoUpdater:
+    """Checks for and manages Riciplay CLI updates."""
+
+    def __init__(self, config_path: Optional[Path] = None):
+        self.config_path = config_path or (Path.home() / ".riciplay" / "update-config.json")
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        self._config = self._load_config()
+
+    def _load_config(self) -> dict:
+        if self.config_path.exists():
+            try:
+                return json.loads(self.config_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, KeyError):
+                pass
+        return {
+            "auto_update": DEFAULT_UPDATE_ENABLED,
+            "channel": DEFAULT_UPDATE_CHANNEL,
+            "check_interval": DEFAULT_UPDATE_CHECK_INTERVAL,
+            "last_check": None,
+            "update_history": [],
+        }
+
+    def _save_config(self) -> None:
+        self.config_path.write_text(json.dumps(self._config, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    @property
+    def is_enabled(self) -> bool:
+        return self._config.get("auto_update", DEFAULT_UPDATE_ENABLED)
+
+    @property
+    def channel(self) -> str:
+        return self._config.get("channel", DEFAULT_UPDATE_CHANNEL)
+
+    @property
+    def should_check(self) -> bool:
+        if not self.is_enabled:
+            return False
+        interval = self._config.get("check_interval", DEFAULT_UPDATE_CHECK_INTERVAL)
+        last = self._config.get("last_check")
+        if not last:
+            return True
+        try:
+            last_time = datetime.fromisoformat(last).timestamp()
+            return (time.time() - last_time) > interval
+        except (ValueError, TypeError):
+            return True
+
+    async def check_for_updates(self) -> Optional[UpdateInfo]:
+        """Check GitHub releases for a newer version. Returns UpdateInfo if available."""
+        if not self.should_check:
+            return None
+
+        try:
+            async with httpx.AsyncClient(timeout=UPDATE_CHECK_TIMEOUT) as client:
+                resp = await client.get(
+                    GITHUB_API_URL,
+                    headers={"Accept": "application/vnd.github.v3+json"},
+                )
+
+                if resp.status_code != 200:
+                    logger.debug("GitHub API returned %d — skipping update check", resp.status_code)
+                    return None
+
+                releases = resp.json()
+                if not releases:
+                    return None
+
+                current_version_str = _get_current_version()
+                current = _parse_version(current_version_str)
+
+                # Filter by channel
+                for release in releases:
+                    tag = release.get("tag_name", "")
+                    is_prerelease = release.get("prerelease", False)
+
+                    # Channel filtering
+                    if self.channel == "stable" and is_prerelease:
+                        continue
+                    elif self.channel == "beta":
+                        if "beta" not in tag.lower() and not is_prerelease:
+                            continue
+                    elif self.channel == "nightly":
+                        if "nightly" not in tag.lower() and "dev" not in tag.lower():
+                            continue
+
+                    try:
+                        release_version = _parse_version(tag)
+                    except (InvalidVersion, ValueError):
+                        continue
+
+                    if release_version > current:
+                        self._config["last_check"] = datetime.now(timezone.utc).isoformat()
+                        self._save_config()
+
+                        return UpdateInfo(
+                            version=tag,
+                            channel=self.channel,
+                            release_notes=release.get("body", "")[:500],
+                            download_url=release.get("html_url", ""),
+                            published_at=release.get("published_at", ""),
+                        )
+
+        except Exception as exc:
+            logger.debug("Update check failed: %s", exc)
+
+        self._config["last_check"] = datetime.now(timezone.utc).isoformat()
+        self._save_config()
+        return None
+
+    def install_update(self) -> tuple[bool, str]:
+        """Install the latest version via pip. Returns (success, message)."""
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--upgrade", "riciplay-cli"],
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            if result.returncode == 0:
+                new_version = _get_current_version()
+                self._config.setdefault("update_history", []).append({
+                    "version": new_version,
+                    "channel": self.channel,
+                    "date": datetime.now(timezone.utc).isoformat(),
+                })
+                self._config["last_check"] = datetime.now(timezone.utc).isoformat()
+                self._save_config()
+                return True, f"Updated to riciplay-cli v{new_version}"
+            else:
+                error_msg = result.stderr.strip()[:200] or result.stdout.strip()[:200]
+                return False, f"pip install failed: {error_msg}"
+
+        except subprocess.TimeoutExpired:
+            return False, "pip install timed out after 60 seconds"
+        except Exception as exc:
+            return False, f"Install failed: {exc}"
+
+    def set_channel(self, channel: str) -> bool:
+        valid = {"stable", "beta", "nightly"}
+        if channel not in valid:
+            return False
+        self._config["channel"] = channel
+        self._save_config()
+        return True
+
+    def set_auto_update(self, enabled: bool) -> None:
+        self._config["auto_update"] = enabled
+        self._save_config()
+
+    def get_status(self) -> dict:
+        return {
+            "current_version": _get_current_version(),
+            "channel": self.channel,
+            "auto_update": self.is_enabled,
+            "last_check": self._config.get("last_check"),
+            "update_history": self._config.get("update_history", []),
+        }
+
+    def manual_update_instructions(self) -> str:
+        return (
+            "To update manually:\n"
+            "  pip install --upgrade riciplay-cli\n"
+            "Or from source:\n"
+            "  cd /path/to/Riciplay/cli && pip install -e ."
+        )