akashcli 4.4.0__tar.gz → 4.5.0__tar.gz

{akashcli-4.4.0 → akashcli-4.5.0}/PKG-INFO

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

{akashcli-4.4.0 → akashcli-4.5.0}/akashcli/cli.py

@@ -179,9 +179,11 @@ def _print_help():
         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}shell{RS}    {DM}[--device NAME]{RS}     open a shell here, on a device, or local",
+        f"  {C}shell{RS}    {DM}--code A3F7B2{RS}       connect via one-time pairing code (no login)",
         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}serve{RS}    {DM}[--share]{RS}           share this shell (prints a pairing code)",
+        f"  {C}serve{RS}    {DM}[--label NAME]{RS}      register device permanently (needs login)",
         f"  {C}devices{RS}  {DM}[--revoke NAME]{RS}     list or revoke enrolled devices",
         f"",
         f"  {DM}FILES{RS}",
@@ -966,27 +968,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 ─────────────────────────────────────────────
@@ -1130,39 +1142,68 @@ 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)"),
+    code:   Optional[str] = typer.Option(None,  "--code",   "-c",
+                                         help="Pairing code from `akash serve` — no login needed"),
 ):
-    """Open an interactive shell — on the server or on an enrolled device.
+    """Open a shell — local, on a device, or via a one-time pairing code.
 
-    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
+      akash serve                     get a pairing code, share it
+      akash shell --code A3F7B2       connect using that code
 
-    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 shell                     full server shell
+      akash shell --device termux     relay shell on enrolled device
+      akash shell --device            auto-pick enrolled device
     """
     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 ───────────────────────
+        # ── Pairing code path (no login needed) ───────────────────────────
+        if code is not None:
+            from .relay import guest_connect_shell
+            c = code.strip().upper()
+            _p()
+            _info(f"connecting with code  {_cy(c)}…")
+            try:
+                exit_code = guest_connect_shell(base, c)
+            except RuntimeError as e:
+                _err(str(e))
+                raise typer.Exit(1)
+            _p()
+            _info("session closed")
+            if exit_code != 0:
+                raise typer.Exit(exit_code)
+            return
+
+        # ── --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"  Or use a pairing code:  {_cy('akash serve')}  →  {_cy('akash shell --code <CODE>')}")
+            _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")
@@ -1170,20 +1211,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…")
@@ -1215,23 +1253,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:
@@ -1297,22 +1355,33 @@ def serve(
     daemon:   bool          = typer.Option(False, "--daemon",    help="Run in background"),
     status:   bool          = typer.Option(False, "--status",    help="Show serve daemon status"),
     stop:     bool          = typer.Option(False, "--stop",      help="Stop background serve daemon"),
+    share:    bool          = typer.Option(False, "--share",     help="Guest mode: get a one-time code, no login needed"),
 ):
-    """Make this device reachable via `akash shell --device` and `akash run --device`.
-
-    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.
-
-    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
+    """Make this device reachable for remote shell — with or without login.
+
+    No login needed (one-time pairing code):
+      akash serve --share            prints a code, share it with anyone
+      akash shell --code A3F7B2      they connect using that code
+
+    With login (permanent, device enrolled):
+      akash serve                    register this device permanently
+      akash serve --daemon           run as background daemon
+      akash serve --label myphone    use a custom label
+      akash serve --status           check daemon status
+      akash serve --stop             stop daemon
     """
     from .relay import serve as _serve, serve_status, serve_stop
 
+    # ── Guest / no-login mode ─────────────────────────────────────────────
+    if share:
+        from .relay import guest_serve
+        _, base = _resolve_client(url)
+        try:
+            guest_serve(base)
+        except KeyboardInterrupt:
+            pass
+        return
+
     if status:
         st = serve_status()
         if st["running"]:
@@ -1320,7 +1389,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:
@@ -1331,13 +1401,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.")
+        _p()
+        _info(f"For a quick one-time session (no login):  {_cy('akash serve --share')}")
+        _p()
+        _info(f"To set up permanently:  {_cy('akash login --label myphone')}  then  {_cy('akash serve')}")
+        _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()

{akashcli-4.4.0 → akashcli-4.5.0}/akashcli/relay.py

@@ -535,3 +535,195 @@ def serve_stop() -> bool:
         return True
     except Exception:
         return False
+
+
+# ── Guest relay (no API key — pairing code) ───────────────────────────────────
+
+def _guest_code_url(base: str) -> str:
+    return f"{base.rstrip('/')}/api/guest/relay/code"
+
+def _guest_host_url(base: str, code: str) -> str:
+    return f"{_ws_base(base)}/api/guest/relay/host?code={code}"
+
+def _guest_join_url(base: str, code: str) -> str:
+    return f"{_ws_base(base)}/api/guest/relay/join?code={code}"
+
+
+def guest_serve(base_url: str) -> None:
+    """
+    Host a shell session with no API key.
+    Requests a pairing code from the server, prints it, then waits for
+    someone to connect with: akash shell --code <CODE>
+    """
+    import httpx
+    import websockets.sync.client as _ws
+
+    # 1. Get a pairing code
+    try:
+        r = httpx.post(_guest_code_url(base_url), timeout=10)
+        r.raise_for_status()
+        code = r.json()["code"]
+        ttl  = r.json().get("expires_in", 600)
+    except Exception as e:
+        print(f"  {_R}✗{_RS}  could not get pairing code: {e}", file=sys.stderr)
+        return
+
+    print()
+    print(f"  {_G}◉{_RS}  guest relay ready")
+    print()
+    print(f"  Your pairing code:  {_C}{_Y}{code}{_RS}")
+    print()
+    print(f"  {_DM}On another machine, run:{_RS}")
+    print(f"    {_C}akash shell --code {code}{_RS}")
+    print()
+    print(f"  {_DM}Code expires in {ttl // 60} min  ·  Ctrl-C to stop{_RS}")
+    print()
+
+    # 2. Connect to host endpoint and serve shell frames
+    while True:
+        try:
+            ws_url = _guest_host_url(base_url, code)
+            with _ws.connect(ws_url, open_timeout=15, close_timeout=5) as ws:
+                ack = json.loads(ws.recv())
+                if ack.get("type") == "error":
+                    print(f"  {_R}✗{_RS}  {ack.get('message')}", file=sys.stderr)
+                    return
+                print(f"  {_DM}waiting for connection…{_RS}")
+                _run_relay_device(ws, f"guest:{code}")
+                print(f"\n  {_DM}session ended — waiting for next connection…{_RS}\n")
+        except KeyboardInterrupt:
+            print(f"\n  {_DM}guest serve stopped{_RS}")
+            break
+        except Exception as exc:
+            print(f"  {_Y}!{_RS}  relay disconnected ({exc}) — reconnecting…")
+            time.sleep(3)
+
+
+def guest_connect_shell(base_url: str, code: str) -> int:
+    """
+    Connect to a guest host by pairing code — no API key needed.
+    Returns the remote exit code.
+    """
+    import websockets.sync.client as _ws
+    import select as _sel, signal
+
+    code = code.strip().upper()
+    ws_url = _guest_join_url(base_url, code)
+
+    from .exec import _get_terminal_size
+    rows, cols = _get_terminal_size()
+
+    _raw_ok = False
+    _old_settings = None
+    _stdin_fd = -1
+    try:
+        import tty, termios as _term
+        _stdin_fd = sys.stdin.fileno()
+        _old_settings = _term.tcgetattr(_stdin_fd)
+        tty.setraw(_stdin_fd)
+        _raw_ok = True
+    except Exception:
+        pass
+
+    def _restore():
+        if _raw_ok and _old_settings is not None:
+            try:
+                import termios as _t
+                _t.tcsetattr(_stdin_fd, _t.TCSADRAIN, _old_settings)
+            except Exception:
+                pass
+
+    exit_code = 1
+    try:
+        with _ws.connect(ws_url, open_timeout=15, close_timeout=10) as ws:
+            ack = json.loads(ws.recv())
+            if ack.get("type") == "error":
+                _restore()
+                raise RuntimeError(ack.get("message", "relay error"))
+
+            ws.send(json.dumps({
+                "type": "pty_run",
+                "command": os.environ.get("SHELL", "/bin/bash"),
+                "rows": rows, "cols": cols,
+            }))
+
+            stop = threading.Event()
+
+            def _stdin_pump():
+                try:
+                    while not stop.is_set():
+                        if _stdin_fd >= 0:
+                            r = _sel.select([_stdin_fd], [], [], 0.05)[0]
+                            if not r:
+                                continue
+                            chunk = os.read(_stdin_fd, 256)
+                        else:
+                            chunk = sys.stdin.buffer.read(1)
+                        if not chunk:
+                            break
+                        ws.send(json.dumps({
+                            "type": "pty_in",
+                            "data": base64.b64encode(chunk).decode(),
+                        }))
+                except Exception:
+                    pass
+
+            def _on_resize(signum, _frame):
+                r, c = _get_terminal_size()
+                try:
+                    ws.send(json.dumps({"type": "resize", "rows": r, "cols": c}))
+                except Exception:
+                    pass
+            try:
+                signal.signal(signal.SIGWINCH, _on_resize)
+            except Exception:
+                pass
+
+            t = threading.Thread(target=_stdin_pump, daemon=True)
+            t.start()
+
+            while True:
+                try:
+                    raw = ws.recv()
+                except Exception:
+                    break
+                try:
+                    frame = json.loads(raw)
+                except Exception:
+                    continue
+                ftype = frame.get("type")
+                if ftype == "pty_out":
+                    data = base64.b64decode(frame["data"])
+                    if data:
+                        sys.stdout.buffer.write(data)
+                        sys.stdout.buffer.flush()
+                elif ftype == "exit":
+                    exit_code = frame.get("code", 0)
+                    stop.set()
+                    break
+                elif ftype == "error":
+                    stop.set()
+                    _restore()
+                    print(f"\r\n{_R}[error]{_RS} {frame.get('message','?')}", file=sys.stderr)
+                    exit_code = 1
+                    break
+                elif ftype == "disconnected":
+                    stop.set()
+                    break
+                elif ftype == "ping":
+                    try:
+                        ws.send(json.dumps({"type": "pong"}))
+                    except Exception:
+                        break
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        stop.set() if 'stop' in dir() else None
+        _restore()
+        try:
+            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+        except Exception:
+            pass
+
+    return exit_code

{akashcli-4.4.0 → akashcli-4.5.0}/akashcli.egg-info/PKG-INFO

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

{akashcli-4.4.0 → akashcli-4.5.0}/pyproject.toml

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