akashcli 4.4.1__tar.gz → 4.5.1__tar.gz

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

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

{akashcli-4.4.1 → akashcli-4.5.1}/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}",
@@ -1142,21 +1144,20 @@ def shell(
     reauth: bool          = typer.Option(False, "--reauth", help="Force re-authentication"),
     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 a shell — local, server, or on any enrolled device.
+    """Open a shell — local, on a device, or via a one-time pairing code.
 
     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
 
-    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
+    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
@@ -1164,13 +1165,30 @@ def shell(
     try:
         api_key, base = _resolve_client(url)
 
+        # ── 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:
             _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")
+            _info(f"  Or use a pairing code:  {_cy('akash serve')}  →  {_cy('akash shell --code <CODE>')}")
             _p()
             raise typer.Exit(1)
 
@@ -1337,21 +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 for remote shell and run.
+    """Make this device reachable for remote shell — with or without login.
 
-    Run this once on a device to register it. Then from any other
-    machine: akash shell --device NAME  or  akash run --device NAME
+    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
 
-    Examples:
-      akash serve                    start in foreground (Ctrl-C to stop)
+    With login (permanent, device enrolled):
+      akash serve                    register this device permanently
       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
+      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"]:
@@ -1380,11 +1410,11 @@ def serve(
 
     if not api_key:
         _p()
-        _warn("not logged in — can't register with relay server.")
+        _warn("not logged in.")
+        _p()
+        _info(f"For a quick one-time session (no login):  {_cy('akash serve --share')}")
         _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}")
+        _info(f"To set up permanently:  {_cy('akash login --label myphone')}  then  {_cy('akash serve')}")
         _p()
         raise typer.Exit(1)
 

{akashcli-4.4.1 → akashcli-4.5.1}/akashcli/relay.py

@@ -535,3 +535,280 @@ 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>
+
+    Security: every incoming connection shows the guest IP + fingerprint
+    and asks the host to approve before the shell is bridged.
+    """
+    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"  {_DM}Pairing code:{_RS}  {_C}{code}{_RS}")
+    print()
+    print(f"  {_DM}On another machine:{_RS}  {_C}akash shell --code {code}{_RS}")
+    print()
+    print(f"  {_DM}Code expires in {ttl // 60} min  ·  Ctrl-C to stop{_RS}")
+    print(f"  {_DM}You will be asked to approve each connection before it gets shell access.{_RS}")
+    print()
+
+    # 2. Connect to host endpoint — handle knock/allow/deny then serve shell
+    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}", flush=True)
+
+                # Wait for either a knock (someone wants in) or a ping
+                while True:
+                    try:
+                        raw = ws.recv(timeout=35)
+                    except Exception:
+                        # Timeout or disconnect — break to reconnect loop
+                        break
+                    frame = json.loads(raw)
+                    ftype = frame.get("type")
+
+                    if ftype == "ping":
+                        ws.send(json.dumps({"type": "pong"}))
+                        continue
+
+                    if ftype == "knock":
+                        guest_ip  = frame.get("ip", "unknown")
+                        fp        = frame.get("fingerprint", "????????")
+                        print()
+                        print(f"  {_Y}⚡{_RS}  Incoming connection request")
+                        print(f"  {_DM}From:{_RS}         {_C}{guest_ip}{_RS}")
+                        print(f"  {_DM}Fingerprint:{_RS}  {_C}{fp}{_RS}")
+                        print()
+
+                        # Prompt host — default is N (deny)
+                        try:
+                            sys.stdout.write(f"  Allow? [y/N]: ")
+                            sys.stdout.flush()
+                            answer = sys.stdin.readline().strip().lower()
+                        except (EOFError, KeyboardInterrupt):
+                            answer = "n"
+
+                        if answer == "y":
+                            ws.send(json.dumps({"type": "allow"}))
+                            print(f"  {_G}✓{_RS}  connection allowed — starting shell…")
+                            print()
+                            # Now serve shell frames
+                            _run_relay_device(ws, f"guest:{code}")
+                            print(f"\n  {_DM}session ended — waiting for next connection…{_RS}\n")
+                        else:
+                            ws.send(json.dumps({"type": "deny"}))
+                            print(f"  {_R}✗{_RS}  connection denied")
+                            print()
+                            # Loop back — still waiting on same code
+                        continue
+
+                    # Any other frame — ignore and keep waiting
+                    continue
+
+        except KeyboardInterrupt:
+            print(f"\n  {_DM}guest serve stopped{_RS}")
+            break
+        except Exception as exc:
+            print(f"  {_Y}!{_RS}  relay disconnected ({exc}) — reconnecting in 3s…")
+            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.
+    Handles the approval handshake: shows a spinner while the host decides,
+    then opens a full PTY shell if approved.
+    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:
+            # First frame: could be error, waiting_approval, or connected
+            first = json.loads(ws.recv())
+            ftype = first.get("type")
+
+            if ftype == "error":
+                _restore()
+                raise RuntimeError(first.get("message", "relay error"))
+
+            if ftype == "waiting_approval":
+                fp = first.get("fingerprint", "")
+                _restore()   # restore terminal so we can print cleanly
+                print(f"  {_Y}…{_RS}  waiting for host to approve this connection…")
+                if fp:
+                    print(f"  {_DM}Your fingerprint:  {_C}{fp}{_RS}")
+                print(f"  {_DM}(host has 30 seconds to respond){_RS}")
+                print()
+                # Wait for next frame: connected or denied
+                try:
+                    second = json.loads(ws.recv(timeout=35))
+                except Exception:
+                    raise RuntimeError("Timed out waiting for host approval.")
+                if second.get("type") == "denied":
+                    raise RuntimeError("Host declined the connection.")
+                if second.get("type") != "connected":
+                    raise RuntimeError(second.get("message", "unexpected response from host"))
+                # Re-enter raw mode for the PTY session
+                try:
+                    import tty as _tty2, termios as _term2
+                    _old_settings = _term2.tcgetattr(_stdin_fd)
+                    _tty2.setraw(_stdin_fd)
+                    _raw_ok = True
+                except Exception:
+                    pass
+            elif ftype != "connected":
+                _restore()
+                raise RuntimeError(first.get("message", "unexpected server response"))
+
+            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.1 → akashcli-4.5.1}/akashcli.egg-info/PKG-INFO

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

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

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