akashcli 4.3.2__tar.gz → 4.4.1__tar.gz

{akashcli-4.3.2 → akashcli-4.4.1}/PKG-INFO

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

{akashcli-4.3.2 → akashcli-4.4.1}/akashcli/cli.py

@@ -142,22 +142,72 @@ def _upload_with_progress(client: AkashClient, tmp_path: str, password=None) ->
 # `cloud_app` — file management (akash cloud upload/files/stream/delete/manage/bulk)
 
 app = typer.Typer(
-    help=(
-        "akash — encrypted cloud backup for your terminal.\n\n"
-        "Quick start:\n"
-        "  akash login          connect your API key\n"
-        "  akash backup         save & sync your terminal\n"
-        "  akash pull <CODE>    restore on a fresh machine\n\n"
-        "Run  akash cloud --help  for file sync commands."
-    ),
+    invoke_without_command=True,
     rich_markup_mode=None,
     add_completion=True,
+    no_args_is_help=False,
 )
+
+@app.callback(invoke_without_command=True)
+def _main(ctx: typer.Context,
+          help: bool = typer.Option(False, "--help", "-h", is_eager=True, expose_value=False,
+                                    callback=lambda v: (_print_help(), raise_exit()) if v else None,
+                                    help="Show this message and exit.")):
+    """akash — your encrypted terminal cloud."""
+    if ctx.invoked_subcommand is None:
+        _print_help()
+        raise typer.Exit(0)
+
+def raise_exit():
+    raise typer.Exit(0)
+
+def _print_help():
+    C, G, Y, DM, RS = _C, _G, _Y, _DM, _RS
+    lines = [
+        f"",
+        f"  {C}akash{RS}  {DM}— encrypted cloud backup · remote shell · file vault{RS}",
+        f"",
+        f"  {DM}ACCOUNT{RS}",
+        f"  {C}login{RS}    {DM}[--label NAME]{RS}      save your API key + name this device",
+        f"  {C}whoami{RS}                        show account info and storage quota",
+        f"  {C}logout{RS}                        clear saved credentials",
+        f"",
+        f"  {DM}TERMINAL BACKUP{RS}",
+        f"  {C}backup{RS}                        save this terminal environment to the cloud",
+        f"  {C}restore{RS}                       restore environment from the cloud",
+        f"  {C}saves{RS}                         list your saved environments",
+        f"  {C}pull{RS}     {DM}<CODE>{RS}               restore on any machine — no login needed",
+        f"",
+        f"  {DM}REMOTE SHELL{RS}",
+        f"  {C}shell{RS}    {DM}[--device NAME]{RS}     open a shell here, or on another device",
+        f"  {C}run{RS}      {DM}<CMD> [--device NAME]{RS}  run a command locally or on a device",
+        f"  {C}serve{RS}    {DM}[--label NAME]{RS}      make this device reachable for shell/run",
+        f"  {C}devices{RS}  {DM}[--revoke NAME]{RS}     list or revoke enrolled devices",
+        f"",
+        f"  {DM}FILES{RS}",
+        f"  {C}pipe{RS}     {DM}[--run CMD]{RS}         upload stdin or a command's output",
+        f"  {C}cloud{RS}    {DM}<upload|files|stream…>{RS}  manage individual cloud files",
+        f"",
+        f"  {DM}SECURE TRANSFER{RS}",
+        f"  {C}send{RS}     {DM}<USER> <FILE>{RS}       encrypt and send a file to another user",
+        f"  {C}inbox{RS}                         receive and decrypt files sent to you",
+        f"  {C}id{RS}                            show your P2P identity / manage contacts",
+        f"",
+        f"  {DM}OTHER{RS}",
+        f"  {C}env{RS}      {DM}<set|get|list…>{RS}     encrypted local .env manager",
+        f"  {C}log{RS}      {DM}[--stats]{RS}           operation history (--stats for summary)",
+        f"  {C}check{RS}    {DM}[--seal]{RS}            verify file integrity (--seal to re-seal)",
+        f"",
+        f"  {DM}Run  {RS}{C}akash <command> --help{RS}{DM}  for full options on any command.{RS}",
+        f"",
+    ]
+    print("\n".join(lines))
+
 cloud_app = typer.Typer(
-    help="akash cloud — upload, stream, manage individual files.",
+    help="Manage individual cloud files.",
     rich_markup_mode=None,
 )
-app.add_typer(cloud_app, name="cloud", help="File sync ops (upload, stream, delete…)")
+app.add_typer(cloud_app, name="cloud", help="upload · stream · delete individual files")
 
 
 # ── Integrity check ───────────────────────────────────────────────────────────
@@ -865,44 +915,37 @@ def pull(
     _print_reload_hint(meta)
 
 
-# ── akash seal ────────────────────────────────────────────────────────────────
+# ── akash check (seal + integrity merged) ────────────────────────────────────
 
 @app.command()
-def seal():
-    """Hash all source files and write a signed integrity manifest."""
-    from .integrity import seal as _seal, _manifest_path
-    _info("sealing source integrity…")
-    hashes = _seal()
-    _ok(f"hashed {len(hashes)} source files")
-    _ok(f"manifest → {_dim(str(_manifest_path()))}")
-    _info("tamper detection active for backup, restore, and pull")
-
-
-# ── akash integrity ───────────────────────────────────────────────────────────
+def check(
+    seal: bool = typer.Option(False, "--seal", help="Re-seal the integrity manifest"),
+):
+    """Verify file integrity — or re-seal with --seal.
 
-@app.command()
-def integrity():
-    """Check all installed source files match the sealed manifest."""
-    from .integrity import status as _status
-    s = _status()
-    if not s["sealed"]:
-        _warn(f"not sealed: {s['message']}")
-        _info("run `akash seal` to enable tamper detection")
-        return
-    if s["ok"]:
-        _ok(f"integrity OK — {s['files']} files verified")
+    Examples:
+      akash check          verify all source files are untampered
+      akash check --seal   hash source files and write a new manifest
+    """
+    if seal:
+        from .integrity import seal as _seal, _manifest_path
+        _info("sealing source integrity…")
+        hashes = _seal()
+        _ok(f"hashed {len(hashes)} source files")
+        _ok(f"manifest → {_dim(str(_manifest_path()))}")
+        _info("tamper detection active for backup, restore, and pull")
     else:
-        _err("tamper detected!")
-        print(s["message"], file=sys.stderr)
-        raise typer.Exit(2)
-
-
-# ── akash docs ────────────────────────────────────────────────────────────────
-
-@app.command()
-def docs():
-    """Open the documentation."""
-    webbrowser.open("https://github.com/juniorsir/akashcli")
+        from .integrity import status as _status
+        s = _status()
+        if not s["sealed"]:
+            _warn(f"not sealed yet — run {_cy('akash check --seal')} to enable tamper detection")
+            return
+        if s["ok"]:
+            _ok(f"integrity OK — {s['files']} files verified")
+        else:
+            _err("tamper detected!")
+            print(s["message"], file=sys.stderr)
+            raise typer.Exit(2)
 
 
 # ── akash logout ─────────────────────────────────────────────────────────────
@@ -923,27 +966,37 @@ def run(
     reauth:    bool          = typer.Option(False, "--reauth",    help="Force re-authentication"),
     save:      bool          = typer.Option(False, "--save",      help="Upload command output to cloud"),
     save_name: Optional[str] = typer.Option(None,  "--save-name", help="Filename for saved output"),
-    device:    Optional[str] = typer.Option(None,  "--device","-d",help="Target device label (default: auto)"),
+    device:    Optional[str] = typer.Option(None,  "--device", "-d",
+                                            help="Run on a device (set up with: akash serve --label NAME)"),
 ):
-    """Run a command — on the server or on a specific enrolled device.
+    """Run a command — locally, on the server, or on an enrolled device.
 
-    Token cached 24 h — instant reconnect every time.
+    No login needed:
+      akash run "df -h"                          runs locally
+      akash run "ls" --save                      runs locally, uploads output
 
-    Examples:
-      akash run "ls -la ~"                       # run on server
-      akash run "df -h" --device termux          # run on your phone
-      akash run "df -h" --device laptop          # run on your laptop
-      akash run "pip list" --save                # save output to cloud
+    With login:
+      akash run "df -h"                          runs on server
+      akash run "df -h" --device termux          runs on your phone
+      akash run "pip list" --save                runs on server, saves output
+
+    To make a device reachable:
+      1. On that device:  akash login --label termux && akash serve
+      2. From anywhere:   akash run "cmd" --device termux
     """
     from .exec import acquire_exec_token, run_command, _clear_cached_token
 
     try:
         api_key, base = _resolve_client(url)
 
-        # ── No key + device flag → relay needs auth ───────────────────────
+        # ── --device but no key ───────────────────────────────────────────
         if device is not None and not api_key:
-            print(_GUEST_WARNING)
-            _err("relay requires an API key. Run `akash login` first.")
+            _warn("relay requires an API key.")
+            _p()
+            _info(f"To run on  {_cy(device.strip() or 'a device')}  you need to log in first:")
+            _info(f"  {_cy('akash login')}         save your API key on this machine")
+            _info(f"  {_cy('akash serve')}          run on the target device to make it reachable")
+            _p()
             raise typer.Exit(1)
 
         # ── Device relay path ─────────────────────────────────────────────
@@ -1087,39 +1140,52 @@ def _build_ws_url_for_run(token: str, base_url: str) -> str:
 def shell(
     url:    Optional[str] = typer.Option(None,  "--url",    help="Override server URL"),
     reauth: bool          = typer.Option(False, "--reauth", help="Force re-authentication"),
-    device: Optional[str] = typer.Option(None,  "--device","-d", help="Target device label (default: auto)"),
+    device: Optional[str] = typer.Option(None,  "--device", "-d",
+                                         help="Device label to connect to (set up with: akash serve --label NAME)"),
 ):
-    """Open an interactive shell — on the server or on an enrolled device.
+    """Open a shell — local, server, or on any enrolled device.
 
-    Full PTY — colours, arrow keys, tab completion, Ctrl-C all work.
-    Token cached 24 h — instant reconnect.
+    No login needed:
+      akash shell                     open a local bash shell
 
-    Examples:
-      akash shell                     # server shell
-      akash shell --device termux     # shell on your phone
-      akash shell --device laptop     # shell on your laptop
-      akash shell --device            # auto (works if only 1 device enrolled)
+    With login (akash login):
+      akash shell                     full server shell (persistent, coloured)
+      akash shell --device termux     relay shell on your phone
+      akash shell --device laptop     relay shell on your laptop
+      akash shell --device            auto-pick (works if only 1 device enrolled)
+
+    To make a device reachable:
+      1. On that device:  akash login --label termux && akash serve
+      2. From anywhere:   akash shell --device termux
     """
     from .exec import acquire_exec_token, run_shell, _clear_cached_token
+    import shutil as _sh, subprocess as _sp
 
     try:
         api_key, base = _resolve_client(url)
 
-        # ── No key + device flag → relay needs auth ───────────────────────
+        # ── --device flag but no key ──────────────────────────────────────
         if device is not None and not api_key:
-            print(_GUEST_WARNING)
-            _err("relay requires an API key. Run `akash login` first.")
+            _warn("relay requires an API key.")
+            _p()
+            _info(f"To connect to  {_cy(device.strip() or 'a device')}  you need to log in first:")
+            _info(f"  {_cy('akash login')}         save your API key on this machine")
+            _info(f"  {_cy('akash serve')}          run on the target device to make it reachable")
+            _p()
             raise typer.Exit(1)
 
         # ── Device relay path ─────────────────────────────────────────────
         if device is not None:
             from .relay import connect_shell
             label = device.strip() if device.strip() else None
-            _info(f"connecting to device  {_cy(label or 'auto')}…")
+            _p()
+            _info(f"connecting to  {_cy(label or 'auto')}…")
             try:
                 exit_code = connect_shell(api_key, base, target=label)
             except RuntimeError as e:
                 _err(str(e))
+                _p()
+                _info(f"Make sure the device is running:  {_cy('akash serve')}")
                 raise typer.Exit(1)
             _p()
             _info("session closed")
@@ -1127,20 +1193,17 @@ def shell(
                 raise typer.Exit(exit_code)
             return
 
-        # ── No key → local PTY shell fallback ────────────────────────────
+        # ── No key → silent local shell ───────────────────────────────────
         if not api_key:
-            import shutil as _sh
-            print(_GUEST_WARNING)
-            _p()
             shell_bin = os.environ.get("SHELL") or _sh.which("bash") or _sh.which("sh") or "/bin/sh"
-            _info(f"opening local shell  {_dim(shell_bin)}")
+            _info(f"local shell  {_dim(shell_bin)}  {_dim('· tip: run akash login to unlock remote shells')}")
             _p()
-            import subprocess as _sp
             result = _sp.run([shell_bin])
             _p()
             _info("session closed")
             raise typer.Exit(result.returncode)
 
+        # ── Server shell ──────────────────────────────────────────────────
         if reauth:
             _clear_cached_token()
             _info("cleared cached token — re-authenticating…")
@@ -1172,23 +1235,43 @@ def devices(
     revoke: Optional[str] = typer.Option(None,  "--revoke", "-r", help="Revoke (unenroll) a device by label"),
     raw:    bool          = typer.Option(False, "--json",          help="Raw JSON output"),
 ):
-    """List enrolled devices or revoke one.
+    """List enrolled devices — or revoke one.
 
-    Each device you log in on with `akash login --label` appears here.
-    The server tracks when each device last authenticated.
+    Each device you run `akash serve` on appears here.
+    Connect from anywhere with: akash shell --device NAME
 
     Examples:
       akash devices                   list all enrolled devices
       akash devices --revoke laptop   remove a device
+
+    Setup:
+      akash login --label phone       name this device
+      akash serve                     register it as reachable
     """
     try:
-        api_key, base = _resolve_client(require_key=True)
+        api_key, base = _resolve_client(require_key=False)
     except typer.Exit:
         raise
     except Exception as e:
         _err(str(e))
         raise typer.Exit(1)
 
+    if not api_key:
+        _p()
+        _info("no devices yet — here's how to set up remote access:")
+        _p()
+        print(f"  {_DM}Step 1 — on each device you want to reach:{_RS}")
+        print(f"    {_cy('akash login --label termux')}   {_DM}(name this device){_RS}")
+        print(f"    {_cy('akash serve')}                  {_DM}(keep running — makes it reachable){_RS}")
+        _p()
+        print(f"  {_DM}Step 2 — from anywhere:{_RS}")
+        print(f"    {_cy('akash shell --device termux')}  {_DM}(open a shell on it){_RS}")
+        print(f"    {_cy('akash run --device termux \"cmd\"')} {_DM}(run a command on it){_RS}")
+        _p()
+        _info(f"Run {_cy('akash login')} first to save your API key.")
+        _p()
+        raise typer.Exit(0)
+
     _hdrs = {"x-api-key": api_key, "Origin": "https://akash.cli"}
 
     if revoke:
@@ -1255,18 +1338,17 @@ def serve(
     status:   bool          = typer.Option(False, "--status",    help="Show serve daemon status"),
     stop:     bool          = typer.Option(False, "--stop",      help="Stop background serve daemon"),
 ):
-    """Make this device reachable via `akash shell --device` and `akash run --device`.
+    """Make this device reachable for remote shell and run.
 
-    Registers this machine with the relay server and waits for incoming
-    shell/run requests. The connection is brokered through your cloud server —
-    no public IP required.
+    Run this once on a device to register it. Then from any other
+    machine: akash shell --device NAME  or  akash run --device NAME
 
     Examples:
-      akash serve                    # foreground (Ctrl-C to stop)
-      akash serve --daemon           # background daemon
-      akash serve --status           # check if daemon is running
-      akash serve --stop             # kill daemon
-      akash serve --label termux     # override device label
+      akash serve                    start in foreground (Ctrl-C to stop)
+      akash serve --daemon           run as background daemon
+      akash serve --status           check if daemon is running
+      akash serve --stop             stop the daemon
+      akash serve --label myphone    use a custom label
     """
     from .relay import serve as _serve, serve_status, serve_stop
 
@@ -1277,7 +1359,8 @@ def serve(
             _ok(f"running  {_dim('pid ' + pid_str)}")
             _info(f"logs  {st['log']}")
         else:
-            _info("not running  — start with: akash serve --daemon")
+            _info("not running")
+            _info(f"start with:  {_cy('akash serve')}  or  {_cy('akash serve --daemon')}")
         return
 
     if stop:
@@ -1288,13 +1371,23 @@ def serve(
         return
 
     try:
-        api_key, base = _resolve_client(url, require_key=True)
+        api_key, base = _resolve_client(url, require_key=False)
     except typer.Exit:
         raise
     except Exception as e:
         _err(str(e))
         raise typer.Exit(1)
 
+    if not api_key:
+        _p()
+        _warn("not logged in — can't register with relay server.")
+        _p()
+        _info("Run this first:")
+        print(f"    {_cy('akash login --label myphone')}   {_DM}# name this device{_RS}")
+        print(f"    {_cy('akash serve')}                   {_DM}# then run this{_RS}")
+        _p()
+        raise typer.Exit(1)
+
     # Resolve label: flag > config > "default"
     from .exec import _device_label as _cfg_label
     resolved_label = (label or _cfg_label() or "default").strip()
@@ -1764,26 +1857,51 @@ def pipe(
     _p()
 
 
-# ── akash log ─────────────────────────────────────────────────────────────────
+# ── akash log (+ --stats) ─────────────────────────────────────────────────────
 
 @app.command(name="log")
 def cmd_log(
-    last:   int            = typer.Option(20,  "--last",  "-n", help="Show last N entries"),
-    op:     Optional[str]  = typer.Option(None,"--op",   "-o", help="Filter by operation type"),
-    raw:    bool           = typer.Option(False,"--json",       help="Raw JSON output"),
+    last:   int            = typer.Option(20,   "--last",  "-n", help="Show last N entries"),
+    op:     Optional[str]  = typer.Option(None, "--op",   "-o", help="Filter by operation type"),
+    raw:    bool           = typer.Option(False, "--json",        help="Raw JSON output"),
+    stats:  bool           = typer.Option(False, "--stats", "-s", help="Show summary instead of list"),
 ):
-    """Show operation history from ~/.akash/log.jsonl.
+    """Show operation history — or a summary with --stats.
 
     Examples:
       akash log                   last 20 operations
+      akash log --stats           summary with counts per operation
       akash log --last 50         last 50 operations
       akash log --op backup       only backup operations
       akash log --json            raw JSON (pipe to jq)
     """
-    from .logger import read_log
+    from .logger import read_log, log_summary
 
-    entries = read_log(last_n=last, op_filter=op)
+    if stats:
+        s = log_summary()
+        if s["total"] == 0:
+            _info("no log entries yet — run some commands first")
+            return
+        _p()
+        print(f"  {_C}◈{_RS}  operation history")
+        _p()
+        _info(f"total       {_ye(str(s['total']))}  "
+              f"({_G}{s['ok']} ok{_RS}" +
+              (f"  {_R}{s['fail']} failed{_RS}" if s["fail"] else "") + ")")
+        _p()
+        for oper, count in sorted(s["by_op"].items(), key=lambda x: -x[1]):
+            bar = "█" * min(count * 2, 24)
+            print(f"  {_C}{oper:<14}{_RS}  {_DM}{bar}{_RS}  {count}")
+        _p()
+        uploads = read_log(last_n=100, op_filter=None)
+        recent = [e for e in uploads if e.get("op") in ("backup", "pipe", "send", "cloud_upload") and e.get("code")]
+        if recent:
+            lu = recent[-1]
+            print(f"  {_DM}last upload  {_RS}{_ye(str(lu.get('code','?')))}  {_dim(str(lu.get('ts',''))[:16].replace('T',' '))}")
+        _p()
+        return
 
+    entries = read_log(last_n=last, op_filter=op)
     if not entries:
         _info("no log entries yet")
         return
@@ -1798,11 +1916,7 @@ def cmd_log(
         oper = e.get("op", "?")
         ok   = e.get("ok", True)
         icon = f"{_G}✓{_RS}" if ok else f"{_R}✗{_RS}"
-
-        # Build a short detail string from the payload
         detail_parts = []
-        for skip in ("ts", "op", "ok", "error"):
-            pass
         for k, v in e.items():
             if k in ("ts", "op", "ok"):
                 continue
@@ -1814,56 +1928,18 @@ def cmd_log(
                 detail_parts.append(f"{k}={_dim(str(v))}")
             else:
                 detail_parts.append(f"{k}={_dim(str(v)[:40])}")
-
         detail = "  ".join(detail_parts[:4])
         print(f"  {icon}  {_GR}{ts}{_RS}  {_C}{oper:<12}{_RS}  {detail}")
     _p()
 
 
-# ── akash stats ───────────────────────────────────────────────────────────────
-
-@app.command()
-def stats():
-    """Show a summary of your akash operation history."""
-    from .logger import log_summary, read_log
-
-    s = log_summary()
-    if s["total"] == 0:
-        _info("no log entries yet — run some commands first")
-        return
-
-    _p()
-    print(f"  {_C}◈{_RS}  operation history")
-    _p()
-    _info(f"total ops      {_ye(str(s['total']))}")
-    _info(f"succeeded      {_G}{s['ok']}{_RS}")
-    if s["fail"]:
-        _info(f"failed         {_R}{s['fail']}{_RS}")
-    _p()
-    print(f"  {_DM}by operation:{_RS}")
-    for op, count in sorted(s["by_op"].items(), key=lambda x: -x[1]):
-        bar_w = min(count * 2, 20)
-        bar   = "█" * bar_w
-        print(f"  {_C}{op:<14}{_RS}  {_dim(bar)}  {count}")
-    _p()
-
-    # Last upload code
-    uploads = read_log(last_n=100, op_filter=None)
-    recent  = [e for e in uploads if e.get("op") in ("backup", "pipe", "send", "cloud_upload") and e.get("code")]
-    if recent:
-        last_up = recent[-1]
-        print(f"  {_DM}last upload  {_RS}{_ye(str(last_up.get('code', '?')))}  "
-              f"{_dim(str(last_up.get('ts', ''))[:16].replace('T',' '))}")
-    _p()
-
-
 # ── akash env ─────────────────────────────────────────────────────────────────
 
 env_app = typer.Typer(
-    help="akash env — encrypted local .env file manager.",
+    help="Encrypted local .env store — set, get, push, pull.",
     rich_markup_mode=None,
 )
-app.add_typer(env_app, name="env", help="Encrypted .env manager (set/get/list/push/pull)")
+app.add_typer(env_app, name="env", help="set · get · push · pull encrypted .env variables")
 
 
 @env_app.command("list")

{akashcli-4.3.2 → akashcli-4.4.1}/akashcli.egg-info/PKG-INFO

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

{akashcli-4.3.2 → akashcli-4.4.1}/pyproject.toml

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