akashcli 4.7.0__tar.gz → 4.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akashcli
-Version: 4.7.0
+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.0 → 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.0"
+    __version__ = "4.7.2"
 
 AKASH_VERSION = __version__
 

{akashcli-4.7.0 → 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():
@@ -204,40 +215,46 @@ def _print_help():
     C, G, Y, DM, RS = _C, _G, _Y, _DM, _RS
     lines = [
         "",
-        f"  {C}akash{RS}  {DM}- encrypted cloud backup · remote terminal · AI tool vault{RS}",
+        f"  {C}akash{RS}  {DM}— encrypted cloud backup · remote shell · AI agent vault{RS}",
         "",
-        f"  {DM}AI & AGENTS{RS}",
-        f"  {C}mcp{RS}      {DM}<serve|share|status>{RS}  serve local tools to Codex, Claude & Cursor",
-        f"  {C}agent{RS}    {DM}<create|list|info…>{RS}   manage AI client credentials & scoped access",
+        f"  {DM}ACCOUNT & SERVER{RS}",
+        f"  {C}login{RS}    {DM}[--label NAME] [--url URL]{RS}     save your API key + name this device",
+        f"  {C}whoami{RS}                                  account quota, storage URL & device info",
+        f"  {C}url{RS}      {DM}[NEW_URL|--reset]{RS}              view or switch configured storage server URL",
+        f"  {C}logout{RS}                                 clear saved credentials from this device",
         "",
         f"  {DM}ENVIRONMENT BACKUP{RS}",
-        f"  {C}backup{RS}   {DM}[--password ...]{RS}      save terminal environment & dotfiles to cloud or local",
-        f"  {C}restore{RS}  {DM}<CODE|PATH>{RS}           restore terminal from cloud save or local archive",
-        f"  {C}pull{RS}     {DM}<CODE>{RS}                one-shot restore on fresh machine (no login needed)",
-        f"  {C}saves{RS}    {DM}[--json]{RS}              list your cloud-saved & local environments",
+        f"  {C}backup{RS}   {DM}[--label NAME] [--password PASS]{RS} save environment & packages to cloud or disk",
+        f"  {C}restore{RS}  {DM}<CODE|PATH> [--dry-run]{RS}        restore terminal environment from cloud or archive",
+        f"  {C}saves{RS}    {DM}[--json]{RS}                       list cloud-saved and local environments",
+        f"  {C}pull{RS}     {DM}<CODE> [--target DIR]{RS}          one-shot restore on fresh machine (no login needed)",
+        "",
+        f"  {DM}REMOTE TERMINAL & SHELL{RS}",
+        f"  {C}shell{RS}    {DM}[DEVICE|--code CODE]{RS}           open interactive shell (local, device, or code)",
+        f"  {C}run{RS}      {DM}<CMD> [--device NAME]{RS}          run command on server or enrolled device",
+        f"  {C}serve{RS}    {DM}[--share] [--label NAME]{RS}       make this device reachable (or get one-time code)",
+        f"  {C}devices{RS}  {DM}[--revoke NAME]{RS}                list or manage enrolled devices",
         "",
-        f"  {DM}REMOTE TERMINAL{RS}",
-        f"  {C}shell{RS}    {DM}[NAME|--code CODE]{RS}    open interactive shell (local, remote device, or code)",
-        f"  {C}run{RS}      {DM}<CMD> [--device NAME]{RS} run command on server or enrolled device",
-        f"  {C}serve{RS}    {DM}[--share]{RS}             make this device reachable (or get one-time code)",
-        f"  {C}devices{RS}  {DM}[--revoke NAME]{RS}       list or manage enrolled devices",
+        f"  {DM}AI AGENTS & MCP{RS}",
+        f"  {C}mcp{RS}      {DM}<serve|share|create|list…>{RS}     AI agent & MCP tool bridge (Codex, Claude, Cursor)",
         "",
-        f"  {DM}FILES & TRANSFERS{RS}",
-        f"  {C}cloud{RS}    {DM}<upload|files|pipe|url…>{RS} cloud file vault, streaming, pipe & storage url",
-        f"  {C}send{RS}     {DM}<USER> <FILE>{RS}         end-to-end encrypted P2P file transfer",
-        f"  {C}inbox{RS}    {DM}[CODE]{RS}                receive & decrypt files sent to your identity",
-        f"  {C}id{RS}       {DM}[--renew]{RS}             view or renew your P2P identity fingerprint",
+        f"  {DM}FILES & CLOUD VAULT{RS}",
+        f"  {C}cloud{RS}    {DM}<upload|files|stream|delete…>{RS}  cloud file vault & media streaming engine",
+        f"  {C}pipe{RS}     {DM}[--name NAME] [--burn]{RS}         pipe stdin or command output directly to cloud vault",
         "",
-        f"  {DM}SYSTEM & SECURITY{RS}",
-        f"  {C}login{RS}    {DM}[--label NAME]{RS}        authenticate & name this device",
-        f"  {C}logout{RS}                        disconnect and clear credentials from this device",
-        f"  {C}whoami{RS}                         account quota, storage URL & device info",
-        f"  {C}url{RS}      {DM}[NEW_URL|--reset]{RS}     view or switch configured storage server URL",
-        f"  {C}version{RS}                        check CLI and server status & versions",
-        f"  {C}env{RS}      {DM}<set|get|list…>{RS}       encrypted local .env store",
-        f"  {C}check{RS}    {DM}[--seal]{RS}              verify source integrity & tamper detection",
+        f"  {DM}SECURE P2P TRANSFERS{RS}",
+        f"  {C}send{RS}     {DM}<USER> <FILE>{RS}                  end-to-end encrypted P2P file transfer",
+        f"  {C}inbox{RS}    {DM}[CODE]{RS}                         receive & decrypt files sent to your identity",
+        f"  {C}id{RS}       {DM}[--export|--add]{RS}               show P2P fingerprint, export key, or add contacts",
         "",
-        f"  {DM}Run  {RS}{C}akash <command> --help{RS}{DM}  for options on any command.{RS}",
+        f"  {DM}SECRETS & SYSTEM{RS}",
+        f"  {C}env{RS}      {DM}<set|get|list|export|push…>{RS}    encrypted local .env store & cloud sync",
+        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}",
         "",
     ]
     nl = chr(10)
@@ -312,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():
@@ -2670,8 +2730,10 @@ def env_pull(
 # AKASH AGENT & DEVICE BINDING COMMANDS
 # =============================================================================
 
-agent_app = typer.Typer(help="Manage AI agents, client credentials & device approvals.")
-app.add_typer(agent_app, name="agent", help="agent credentials · device binding · approvals")
+mcp_app = typer.Typer(help="Model Context Protocol (MCP) server & AI agent tool bridge.")
+agent_app = mcp_app
+app.add_typer(mcp_app, name="mcp", help="MCP server · AI agent tools · Claude/Cursor/Codex bridge")
+app.add_typer(mcp_app, name="agent", hidden=True, help="Alias for akash mcp")
 
 def _render_inspection_card(r: dict) -> None:
     print(f"\n  {_C}╭─ ⚡ INCOMING AGENT DEVICE REGISTRATION ────────────────────────────{_RS}")
@@ -2861,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)")
@@ -2932,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
@@ -2983,30 +3054,6 @@ def agent_create(
         print(f"  {_G}akash mcp serve --id {profile_id}{_RS}")
     _p()
 
-@agent_app.command("update")
-def agent_update(
-    client_id: str = typer.Argument(..., help="Client ID of the agent to update"),
-    scopes: str = typer.Option(..., "--scopes", "-s", help="New scopes or role preset (e.g., @coder, +exec:package_install)"),
-    url: Optional[str] = typer.Option(None, "--url", help="Override server URL"),
-):
-    """Update permissions/scopes for an existing AI Agent application."""
-    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
-
-    with _Spin(f"updating permissions for {client_id}…"):
-        res = httpx.patch(
-            f"{base}/api/agent/app/{client_id}",
-            headers=hdrs,
-            json={"scopes": scopes},
-            timeout=10.0
-        )
-    if res.status_code == 200:
-        d = res.json()
-        _ok(f"Agent {_ye(client_id)} permissions updated to: {_cy(d.get('scopes', ''))}")
-    else:
-        _err(f"Failed to update scopes: {res.text}")
-
 @agent_app.command("requests")
 def agent_requests(url: Optional[str] = typer.Option(None, "--url", help="Override server URL")):
     """List pending device registration requests."""
@@ -3094,64 +3141,11 @@ def agent_reject(request_id: str, url: Optional[str] = typer.Option(None, "--url
     else:
         _err(f"Rejection failed: {res.text}")
 
-@app.command("guard")
-def guard_console(url: Optional[str] = typer.Option(None, "--url", help="Override server URL")):
-    import time
-    """Interactive real-time terminal console that listens for agent access requests."""
-    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
-    print(f"\n  {_G}◉{_RS}  {_W}Akash Guard Console Online{_RS}")
-    print(f"  {_DM}Listening for incoming agent device registrations (Ctrl-C to stop)…{_RS}\n")
-
-    handled_requests = set()
-    while True:
-        try:
-            res = httpx.get(
-                f"{base}/api/agent/requests",
-                headers=hdrs,
-                timeout=5.0
-            )
-            if res.status_code == 200:
-                for r in res.json().get("requests", []):
-                    rid = r["request_id"]
-                    if r["status"] == "pending" and rid not in handled_requests:
-                        _render_inspection_card(r)
-                        try:
-                            sys.stdout.write(f"  Approve access for this device? [y/N]: ")
-                            sys.stdout.flush()
-                            choice = sys.stdin.readline().strip().lower()
-                        except (KeyboardInterrupt, EOFError):
-                            choice = "n"
-
-                        if choice == "y":
-                            httpx.post(f"{base}/api/agent/requests/{rid}/approve", headers=hdrs, timeout=5)
-                            _ok(f"Approved {rid} - Access token released to agent!\n")
-                        else:
-                            httpx.post(f"{base}/api/agent/requests/{rid}/reject", headers=hdrs, timeout=5)
-                            _warn(f"Rejected {rid}.\n")
-                        handled_requests.add(rid)
-            time.sleep(2.0)
-        except KeyboardInterrupt:
-            print(f"\n  {_DM}Guard console stopped.{_RS}\n")
-            break
-        except Exception:
-            time.sleep(3.0)
-
 
 # =============================================================================
-# MODEL CONTEXT PROTOCOL (MCP) V6 POWER-SUITE
+# MODEL CONTEXT PROTOCOL (MCP) & AI AGENT ENGINE (MERGED)
 # =============================================================================
 
-mcp_app = typer.Typer(help="Model Context Protocol (MCP) server for AI agents.")
-app.add_typer(mcp_app, name="mcp", help="Model Context Protocol (MCP) bridge for AI agents")
-mcp_app.command("guard", help="Terminal approval console for incoming agent requests")(guard_console)
-
-@mcp_app.command("list")
-def mcp_list(raw: bool = typer.Option(False, "--json", help="Raw JSON output")):
-    """List all available Agent Profile IDs for MCP."""
-    agent_list(raw=raw)
-
 _ASYNC_JOBS = {}
 _LAST_UNDO_DIR = Path.home() / ".akash" / "undo_vault"
 
@@ -3268,7 +3262,7 @@ def _parse_temp_duration(val: str) -> int:
     elif unit in ('d', 'day', 'days'): return num * 1440
     return num
 
-@mcp_app.command("serve")
+@agent_app.command("serve")
 def mcp_serve(
     url: Optional[str] = typer.Option(None, "--url", help="Override server URL"),
     client_id: Optional[str] = typer.Option(None, "--client-id", help="Agent Client ID"),
@@ -3449,8 +3443,8 @@ def mcp_serve(
             print(f"  {_GR}{now_t}{_RS}  {_Y}⚠{_RS}  {_dim(f'Worker disconnected ({e}). Reconnecting in {backoff:.1f}s (attempt {reconnect_attempts})…')}")
             time.sleep(backoff)
 
-@mcp_app.command("share")
-@mcp_app.command("url", hidden=True)
+@agent_app.command("share")
+@agent_app.command("url", hidden=True)
 def mcp_share(
     target:  Optional[str] = typer.Argument(None, help="Profile ID (optional if only 1 profile exists)"),
     id:      Optional[str] = typer.Option(None, "--id", "-i", help="Profile ID"),
@@ -3642,123 +3636,7 @@ def mcp_share(
     _p()
 
 
-@mcp_app.command("url", hidden=True)
-def mcp_share(
-    target:  Optional[str] = typer.Argument(None, help="Profile ID (optional if only 1 profile exists)"),
-    id:      Optional[str] = typer.Option(None, "--id", "-i", help="Profile ID"),
-    temp:    Optional[str] = typer.Option(None, "--temp", "-t", help="Temporary short URL duration (e.g. '30m', '30 min', '1h')"),
-    codex:   bool          = typer.Option(False, "--codex", "-c", help="Show snippet only for Codex CLI/Desktop"),
-    claude:  bool          = typer.Option(False, "--claude", help="Show snippet only for Claude Desktop / Cursor"),
-    keys:    bool          = typer.Option(False, "--keys", "-k", help="Show raw Client ID and Secret"),
-    url:     Optional[str] = typer.Option(None, "--url", help="Override server URL"),
-):
-    """Generate ready-to-copy MCP configuration for Codex, Claude, or Cursor on ANY device."""
-    import json, urllib.parse
-    from pathlib import Path
-
-    agents_file = Path.home() / ".akash" / "agents.json"
-    if not agents_file.exists():
-        _err("No saved agent profiles found. Create one with: akash agent create")
-        raise typer.Exit(1)
-
-    try:
-        agents = json.loads(agents_file.read_text(encoding="utf-8"))
-    except Exception: agents = {}
-
-    target_id = id or target
-    if not target_id:
-        if len(agents) == 1:
-            target_id = next(iter(agents.keys()))
-        elif "af4f" in agents:
-            target_id = "af4f"
-        else:
-            _err("Multiple profiles found. Specify which one: akash mcp share <ID>")
-            raise typer.Exit(1)
-
-    pid, cid, name = _resolve_agent_id(target_id)
-    profile = agents.get(pid, {})
-    csec = profile.get("client_secret", "")
-
-    if not csec:
-        _err(f"No client_secret found for profile {pid}.")
-        raise typer.Exit(1)
-
-    _, base = _resolve_client(url or profile.get("url"), require_key=False, silent=True)
-    dev_fp = _device_fingerprint()
-
-    lan_ip = _get_lan_ip()
-    port = base.split(":")[-1] if ":" in base.replace("http://", "").replace("https://", "") else "8000"
-    wifi_base = f"http://{lan_ip}:{port}"
-
-    if temp:
-        try:
-            ttl_min = _parse_temp_duration(temp)
-        except ValueError as ve:
-            _err(str(ve))
-            raise typer.Exit(1)
-
-        with _Spin(f"generating {ttl_min}m short link…"):
-            try:
-                res = httpx.post(
-                    f"{base}/api/agent/mcp/ticket",
-                    json={"client_id": cid, "client_secret": csec, "device_fp": dev_fp, "ttl_minutes": ttl_min},
-                    timeout=10.0
-                )
-                res.raise_for_status()
-                d = res.json()
-                tcode = d["ticket_code"]
-                local_url = f"{base}/mcp/t/{tcode}"
-                wifi_url = f"{wifi_base}/mcp/t/{tcode}"
-                mode_label = f"Temporary ({ttl_min} mins · Ephemeral)"
-            except Exception as e:
-                _err(f"Failed to issue temporary ticket: {e}")
-                raise typer.Exit(1)
-    else:
-        params = urllib.parse.urlencode({"cid": cid, "csec": csec, "dfp": dev_fp})
-        local_url = f"{base}/mcp?{params}"
-        wifi_url = f"{wifi_base}/mcp?{params}"
-        mode_label = "Permanent Small & Secure"
-
-    _p()
-    print("  " + _C + "◈" + _RS + "  " + _W + "Akash MCP  ·  Quick Connect" + _RS)
-    print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
-    print("  " + _DM + "Agent    : " + _RS + _ye(name) + " " + _dim("(" + pid + ")"))
-    print("  " + _DM + "Mode     : " + _RS + _C + mode_label + _RS)
-    if keys:
-        print("  " + _DM + "Client ID: " + _RS + _dim(cid))
-        print("  " + _DM + "Secret   : " + _RS + _dim(csec))
-        print("  " + _DM + "Device FP: " + _RS + _dim(dev_fp))
-    print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
-    _p()
-
-    show_all = not codex and not claude
-
-    if show_all or codex:
-        print("  " + _C + "For Codex CLI / Desktop" + _RS + " " + _dim("(~/.codex/config.toml)") + ":")
-        print("  " + _DM + "Option A: Same Device (Termux / Localhost)" + _RS)
-        print("  [mcp_servers.akash]")
-        print('  url = "' + local_url + '"')
-        if lan_ip != "127.0.0.1":
-            print()
-            print("  " + _DM + "Option B: Other Device (Over Wi-Fi)" + _RS)
-            print("  [mcp_servers.akash]")
-            print('  url = "' + wifi_url + '"')
-        print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
-        _p()
-
-    if show_all or claude:
-        print("  " + _C + "For Claude Desktop / Cursor" + _RS + " " + _dim("(config.json)") + ":")
-        claude_cfg = json.dumps({"mcpServers": {"akash": {"url": local_url}}}, indent=2)
-        for c_line in claude_cfg.splitlines():
-            print("  " + c_line)
-        print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
-        _p()
-
-    _info("Paste snippet into AI client, then keep running:")
-    _info(f"  {_cy('akash mcp serve')}")
-    _p()
-
-@mcp_app.command("status")
+@agent_app.command("status")
 def mcp_status(
     url: Optional[str] = typer.Option(None, "--url", help="Override server URL")
 ):

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.0 → akashcli-4.7.2}/akashcli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akashcli
-Version: 4.7.0
+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.0 → 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.0 → akashcli-4.7.2}/pyproject.toml

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