akashcli 4.7.1__tar.gz → 4.7.2__tar.gz

{akashcli-4.7.1 → akashcli-4.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akashcli
-Version: 4.7.1
+Version: 4.7.2
 Summary: Akash CLI — secure remote shell relay, file vault, and device management
 License-Expression: MIT
 Keywords: akash,cli,relay,remote-shell,vault

{akashcli-4.7.1 → akashcli-4.7.2}/akashcli/__init__.py

@@ -2,7 +2,7 @@ try:
     from importlib.metadata import version
     __version__ = version("akashcli")
 except Exception:
-    __version__ = "4.7.1"
+    __version__ = "4.7.2"
 
 AKASH_VERSION = __version__
 

{akashcli-4.7.1 → akashcli-4.7.2}/akashcli/cli.py

@@ -6,6 +6,7 @@ import subprocess
 import re
 import webbrowser
 import tempfile
+import atexit
 from typing import Optional, List
 from pathlib import Path
 
@@ -18,6 +19,9 @@ from .config import ConfigManager, DEFAULT_STORAGE_URL
 from .exceptions import AkashError
 from .exec import _device_fingerprint
 from .uploader import VaultUploader
+from .updater import show_update_warning_if_available, check_for_updates, format_update_box, mark_update_printed
+
+atexit.register(show_update_warning_if_available)
 
 # ── ANSI palette (matches exec.py) ───────────────────────────────────────────
 _C  = "\033[1;36m"   # cyan bold
@@ -184,6 +188,13 @@ def _version_callback(value: bool):
     if value:
         from . import __version__
         print(f"akashcli v{__version__}")
+        try:
+            available, latest = check_for_updates(__version__, force_sync=False)
+            if available and latest:
+                print(format_update_box(__version__, latest))
+                mark_update_printed()
+        except Exception:
+            pass
         raise typer.Exit(0)
 
 def raise_exit():
@@ -241,6 +252,7 @@ def _print_help():
         f"  {C}log{RS}      {DM}[--stats]{RS}                      view operation history & bandwidth summary",
         f"  {C}check{RS}    {DM}[--seal]{RS}                       verify source integrity & tamper detection",
         f"  {C}version{RS}                                 check CLI and server status & versions",
+        f"  {C}update{RS}                                  check and install latest akashcli release",
         "",
         f"  {DM}Run  {RS}{C}akash <command> --help{RS}{DM}  for full options on any command.{RS}",
         "",
@@ -317,7 +329,50 @@ def version(url: Optional[str] = typer.Option(None, "--url", help="Server URL to
             print(f"  {_DM}server   {_RS}{_cy(base)}  {_dim(f'(HTTP {resp.status_code})')}")
     except Exception:
         print(f"  {_DM}server   {_RS}{_cy(base)}  {_dim('(unreachable)')}")
-    print()
+
+    try:
+        available, latest = check_for_updates(__version__, force_sync=True)
+        if available and latest:
+            print(format_update_box(__version__, latest))
+            mark_update_printed()
+        else:
+            print(f"  {_G}✓{_RS}  {_DM}akashcli is up to date{_RS}\n")
+    except Exception:
+        print()
+
+@app.command()
+def update():
+    """Check for updates and upgrade akashcli to the latest version."""
+    from . import __version__
+    _p()
+    print(f"  {_C}◈{_RS}  {_W}Checking for akashcli updates…{_RS}")
+    available, latest = check_for_updates(__version__, force_sync=True)
+    if not available or not latest:
+        _ok(f"akashcli is already at the latest version ({_cy('v' + __version__)})")
+        _p()
+        return
+
+    print(f"  {_Y}⚡{_RS} New version available: {_DM}{__version__}{_RS} {_C}→{_RS} {_G}{latest}{_RS}")
+    with _Spin(f"updating akashcli to v{latest}…"):
+        cmd = [sys.executable, "-m", "pip", "install", "-U", "akashcli", "--break-system-packages"]
+        res = subprocess.run(cmd, capture_output=True, text=True)
+        if res.returncode != 0:
+            cmd = [sys.executable, "-m", "pip", "install", "-U", "akashcli"]
+            res = subprocess.run(cmd, capture_output=True, text=True)
+
+    if res.returncode == 0:
+        _ok(f"Successfully updated akashcli to {_G}v{latest}{_RS}!")
+        try:
+            from .integrity import seal
+            seal()
+            _ok("Integrity manifest re-sealed.")
+        except Exception:
+            pass
+    else:
+        _err(f"Update failed: {res.stderr or res.stdout}")
+        _info(f"Please run manually: {_cy('pip install -U akashcli')}")
+    mark_update_printed()
+    _p()
 
 @app.command()
 def whoami():
@@ -2868,6 +2923,8 @@ def agent_update(
         _err("Provide a Profile ID (e.g. 'akash agent update fbf6 --scopes +exec:package_install')")
         raise typer.Exit(1)
 
+    if role and not role.startswith("@") and role in ("viewer", "coder", "tester", "full"):
+        role = "@" + role
     effective_scopes = scopes if scopes else role
     if not effective_scopes:
         _err("Specify new scopes with --scopes or --role (e.g. --scopes +exec:package_install or --role @coder)")
@@ -2939,6 +2996,13 @@ def agent_create(
     url: Optional[str] = typer.Option(None, "--url", help="Override server URL"),
 ):
     """Generate new Client ID and Client Secret with hardware binding."""
+    if role:
+        if not role.startswith("@") and role in ("viewer", "coder", "tester", "full"):
+            role = "@" + role
+        effective_scopes = role
+    else:
+        effective_scopes = scopes
+
     api_key, base = _resolve_client(url, require_key=False)
     hdrs = {"Origin": "https://akash.cli", "x-device-id": _device_fingerprint()}
     if api_key: hdrs["x-api-key"] = api_key

akashcli-4.7.2/akashcli/updater.py

@@ -0,0 +1,225 @@
+"""
+updater.py — Asynchronous, cached PyPI update checker for akashcli.
+
+- Queries PyPI (https://pypi.org/pypi/akashcli/json) for the latest release.
+- Caches response in ~/.akash/update_check.json with a 6-hour TTL.
+- Background refresh runs detached so CLI commands have 0ms network latency.
+- Renders an aligned, non-intrusive warning box when an update is available.
+"""
+
+import os
+import sys
+import json
+import time
+import subprocess
+import unicodedata
+import re
+from pathlib import Path
+from typing import Optional, Dict, Tuple
+
+CACHE_FILE = Path.home() / ".akash" / "update_check.json"
+CHECK_INTERVAL_SECONDS = 6 * 3600  # 6 hours
+PYPI_URL = "https://pypi.org/pypi/akashcli/json"
+
+_already_printed = False
+
+# ANSI Color Palette
+_C  = "\033[1;36m"   # cyan bold
+_W  = "\033[1;37m"   # white bold
+_G  = "\033[1;32m"   # green bold
+_Y  = "\033[1;33m"   # yellow bold
+_DM = "\033[2m"      # dim
+_GR = "\033[90m"     # gray
+_RS = "\033[0m"      # reset
+
+
+def _cell_width(text: str) -> int:
+    """Calculate terminal display width accounting for wide characters and ANSI codes."""
+    clean = re.sub(r'\x1b\[[0-9;]*m', '', text)
+    width = 0
+    for ch in clean:
+        if unicodedata.east_asian_width(ch) in ('W', 'F'):
+            width += 2
+        else:
+            width += 1
+    return width
+
+
+def is_newer_version(latest: str, current: str) -> bool:
+    """Compare two semantic version strings safely."""
+    if not latest or not current:
+        return False
+    try:
+        from packaging.version import parse
+        return parse(latest) > parse(current)
+    except Exception:
+        try:
+            def to_tuple(v: str) -> Tuple[int, ...]:
+                nums = [int(x) for x in re.findall(r'\d+', v.split("+")[0])]
+                return tuple(nums)
+            return to_tuple(latest) > to_tuple(current)
+        except Exception:
+            return False
+
+
+def fetch_latest_version(timeout: float = 2.0) -> Optional[str]:
+    """Synchronously fetch the latest version of akashcli from PyPI."""
+    try:
+        import httpx
+        with httpx.Client(timeout=timeout) as client:
+            resp = client.get(PYPI_URL)
+            if resp.status_code == 200:
+                data = resp.json()
+                return data.get("info", {}).get("version")
+    except Exception:
+        pass
+    return None
+
+
+def read_cache() -> Optional[Dict]:
+    """Read the cached update check result."""
+    try:
+        if CACHE_FILE.exists():
+            return json.loads(CACHE_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        pass
+    return None
+
+
+def write_cache(latest_version: str):
+    """Write the latest version to cache."""
+    try:
+        CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            "last_checked": time.time(),
+            "latest_version": latest_version
+        }
+        CACHE_FILE.write_text(json.dumps(data), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def trigger_background_check():
+    """Trigger a detached background process to query PyPI and update the cache."""
+    try:
+        subprocess.Popen(
+            [sys.executable, "-m", "akashcli.updater"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,
+            close_fds=True,
+        )
+    except Exception:
+        pass
+
+
+def check_for_updates(current_version: str, force_sync: bool = False) -> Tuple[bool, Optional[str]]:
+    """
+    Check if an update is available.
+    Returns (is_available, latest_version).
+    """
+    if os.environ.get("AKASH_NO_UPDATE_CHECK", "").lower() in ("1", "true", "yes"):
+        return False, None
+    if os.environ.get("CI", "").lower() in ("1", "true", "yes"):
+        return False, None
+
+    now = time.time()
+    cache = read_cache()
+
+    if force_sync:
+        latest = fetch_latest_version(timeout=2.0)
+        if latest:
+            write_cache(latest)
+            return is_newer_version(latest, current_version), latest
+        # If fetch fails, fall back to cache
+        if cache and "latest_version" in cache:
+            latest = cache["latest_version"]
+            return is_newer_version(latest, current_version), latest
+        return False, None
+
+    # Check cache TTL
+    needs_refresh = True
+    if cache and isinstance(cache, dict):
+        last_checked = cache.get("last_checked", 0)
+        if (now - last_checked) < CHECK_INTERVAL_SECONDS:
+            needs_refresh = False
+
+    if needs_refresh:
+        trigger_background_check()
+
+    if cache and "latest_version" in cache:
+        latest = cache["latest_version"]
+        if is_newer_version(latest, current_version):
+            return True, latest
+
+    return False, None
+
+
+def format_update_box(current: str, latest: str) -> str:
+    """Format a styled, pixel-aligned terminal banner for the update notification."""
+    line1 = f"  {_Y}⚡{_RS} {_W}Update available:{_RS} {_DM}{current}{_RS} {_C}→{_RS} {_G}{latest}{_RS}"
+    cmd_str = "pip install -U akashcli"
+    line2 = f"  {_DM}Run:{_RS} {_C}{cmd_str}{_RS} {_DM}to update{_RS}"
+
+    w1 = _cell_width(line1)
+    w2 = _cell_width(line2)
+
+    width = max(w1, w2) + 4
+    pad1 = width - w1
+    pad2 = width - w2
+
+    top = f"  {_GR}╭{'─' * width}╮{_RS}"
+    mid1 = f"  {_GR}│{_RS}{line1}{' ' * pad1}{_GR}│{_RS}"
+    mid2 = f"  {_GR}│{_RS}{line2}{' ' * pad2}{_GR}│{_RS}"
+    bot = f"  {_GR}╰{'─' * width}╯{_RS}"
+
+    return f"\n{top}\n{mid1}\n{mid2}\n{bot}\n"
+
+
+def should_suppress_notice() -> bool:
+    """Check if the notice should be suppressed (e.g. non-tty or json/pipe output)."""
+    if os.environ.get("AKASH_NO_UPDATE_CHECK", "").lower() in ("1", "true", "yes"):
+        return True
+    if not sys.stdout.isatty():
+        return True
+    # Suppress in quiet or raw data commands
+    for arg in sys.argv[1:]:
+        if arg in ("--json", "--raw", "--quiet", "-q", "pipe", "stream"):
+            return True
+    return False
+
+
+def show_update_warning_if_available():
+    """Atexit / teardown hook: show update warning if available and not yet printed."""
+    global _already_printed
+    if _already_printed:
+        return
+    if should_suppress_notice():
+        return
+
+    try:
+        from . import __version__
+        available, latest = check_for_updates(__version__, force_sync=False)
+        if available and latest:
+            _already_printed = True
+            print(format_update_box(__version__, latest))
+    except Exception:
+        pass
+
+
+def mark_update_printed():
+    """Mark update warning as printed so it won't duplicate on exit."""
+    global _already_printed
+    _already_printed = True
+
+
+def main():
+    """Background worker entry point: python3 -m akashcli.updater"""
+    latest = fetch_latest_version(timeout=4.0)
+    if latest:
+        write_cache(latest)
+
+
+if __name__ == "__main__":
+    main()

{akashcli-4.7.1 → akashcli-4.7.2}/akashcli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akashcli
-Version: 4.7.1
+Version: 4.7.2
 Summary: Akash CLI — secure remote shell relay, file vault, and device management
 License-Expression: MIT
 Keywords: akash,cli,relay,remote-shell,vault

{akashcli-4.7.1 → akashcli-4.7.2}/akashcli.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ akashcli/restore.py
 akashcli/snapshot_crypto.py
 akashcli/storage.py
 akashcli/terminal.py
+akashcli/updater.py
 akashcli/uploader.py
 akashcli/utils.py
 akashcli.egg-info/PKG-INFO

{akashcli-4.7.1 → akashcli-4.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "akashcli"
-version = "4.7.1"
+version = "4.7.2"
 description = "Akash CLI — secure remote shell relay, file vault, and device management"
 readme = "README.md"
 requires-python = ">=3.9"