akashcli 4.5.8__tar.gz → 4.6.0__tar.gz

{akashcli-4.5.8 → akashcli-4.6.0}/PKG-INFO

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

{akashcli-4.5.8 → akashcli-4.6.0}/akashcli/_net.py

@@ -113,6 +113,10 @@ def ws_connect(url: str, **kwargs):
     sock_timeout = kwargs.pop("_sock_timeout", 15)
     sock = make_socket(host, port, timeout=sock_timeout)
 
+    # legacy=True: allow calling connect() outside of a `with` block.
+    # websockets ≥ 13 requires context manager usage by default;
+    # legacy mode silences the deprecation and preserves the old API.
+    kwargs.setdefault("legacy", True)
     if use_tls:
         return _wsc.connect(url, sock=sock, ssl=ssl_context(), **kwargs)
     return _wsc.connect(url, sock=sock, **kwargs)

{akashcli-4.5.8 → akashcli-4.6.0}/akashcli/relay.py

@@ -805,19 +805,19 @@ def _sh_history(history: list) -> None:
 def guest_connect_shell(base_url: str, code: str) -> int:
     """
     Connect to a guest host via pairing code.
-    Uses a Python REPL loop with DevOS-style UI — no raw-mode PTY needed on
-    the client side.  The remote side runs a persistent bash that we drive with
-    `run` frames; output is shown with inset │ borders.
-    Returns the last remote exit code.
+    Opens a real PTY tunnel to the host's shell — identical to connect_shell()
+    but uses the guest relay (no API key).  Full interactive terminal: nano,
+    vim, htop, etc. all work.  DevOS banner is printed before entering raw mode.
+    Returns the remote exit code.
     """
-    import readline as _rl
-    import queue as _q
+    import select as _sel
+    import signal
 
     code = code.strip().upper()
     ws_url = _guest_join_url(base_url, code)
 
-    # ── Connect & handle approval ─────────────────────────────────────────────
-    print(f"\n  {_C}◈{_RS}  {_DM}connecting…{_RS}")
+    # ── Connect & handle approval (before entering raw mode) ─────────────────
+    print(f"\n  {_C}◈{_RS}  {_DM}connecting…{_RS}", flush=True)
     try:
         ws = _ws_connect(ws_url, open_timeout=15, close_timeout=10)
     except Exception as e:
@@ -832,10 +832,10 @@ def guest_connect_shell(base_url: str, code: str) -> int:
 
     if ftype == "waiting_approval":
         fp = first.get("fingerprint", "")
-        print(f"  {_C}◈{_RS}  {_DM}waiting for host to approve…{_RS}")
+        print(f"  {_C}◈{_RS}  {_DM}waiting for host to approve…{_RS}", flush=True)
         if fp:
-            print(f"  {_DM}fingerprint  {_C}{fp}{_SH_RS}")
-        print(f"  {_DM}host has 30 s to respond{_RS}\n")
+            print(f"  {_DM}fingerprint  {_C}{fp}{_RS}", flush=True)
+        print(f"  {_DM}host has 30 s to respond{_RS}\n", flush=True)
         try:
             second = json.loads(ws.recv(timeout=35))
         except Exception:
@@ -851,213 +851,145 @@ def guest_connect_shell(base_url: str, code: str) -> int:
         ws.close()
         raise RuntimeError(first.get("message", "unexpected server response"))
 
-    # ── Session state ─────────────────────────────────────────────────────────
-    cwd      = os.path.expanduser("~")
-    history  : list[str] = []
-    exit_code = 0
-    identity  = os.environ.get("USER") or os.environ.get("LOGNAME") or "akash"
+    # ── Print DevOS banner (before raw mode) ──────────────────────────────────
+    identity = os.environ.get("USER") or os.environ.get("LOGNAME") or "akash"
+    print(f"\n  {_G}◉{_RS}  {_C}akash shell{_RS}  "
+          f"{_DM}code {code}  ·  Ctrl-D or `exit` to quit{_RS}\n", flush=True)
 
-    # readline history setup
-    hist_file = _AKASH_DIR / "shell_history"
-    _AKASH_DIR.mkdir(parents=True, exist_ok=True)
+    # ── Get terminal size ─────────────────────────────────────────────────────
     try:
-        _rl.read_history_file(str(hist_file))
+        import shutil as _sh
+        cols, rows = _sh.get_terminal_size(fallback=(80, 24))
     except Exception:
-        pass
-    _rl.set_history_length(500)
+        rows, cols = 24, 80
 
-    # ── Output queue — background thread feeds frames ─────────────────────────
-    q: _q.Queue = _q.Queue()
-    stop_recv = threading.Event()
+    # ── Enter raw mode ────────────────────────────────────────────────────────
+    _raw_ok = False
+    _old_settings = None
+    _stdin_fd = -1
+    try:
+        import tty as _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 _recv_loop():
-        while not stop_recv.is_set():
+    def _restore():
+        if _raw_ok and _old_settings is not None:
             try:
-                raw = ws.recv(timeout=0.1)
-                q.put(raw)
+                import termios as _t
+                _t.tcsetattr(_stdin_fd, _t.TCSADRAIN, _old_settings)
             except Exception:
-                if not stop_recv.is_set():
-                    q.put(None)   # signals disconnection
-                break
+                pass
+
+    exit_code = 0
+    stop = threading.Event()
+
+    # ── Tell host to open a PTY shell ─────────────────────────────────────────
+    try:
+        ws.send(json.dumps({
+            "type":    "pty_run",
+            "command": os.environ.get("SHELL", "/bin/bash"),
+            "rows":    rows,
+            "cols":    cols,
+        }))
+    except Exception as e:
+        _restore()
+        ws.close()
+        raise RuntimeError(f"Failed to start remote shell: {e}")
+
+    # ── Thread: local stdin → WS ──────────────────────────────────────────────
+    def _stdin_pump():
+        try:
+            while not stop.is_set():
+                if _stdin_fd >= 0:
+                    r = _sel.select([_stdin_fd], [], [], 0.02)[0]
+                    if not r:
+                        continue
+                    chunk = os.read(_stdin_fd, 4096)
+                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
+
+    # ── SIGWINCH → resize frame ───────────────────────────────────────────────
+    def _on_resize(signum, _frame):
+        try:
+            import shutil as _sh2
+            c2, r2 = _sh2.get_terminal_size(fallback=(80, 24))
+            ws.send(json.dumps({"type": "resize", "rows": r2, "cols": c2}))
+        except Exception:
+            pass
+    try:
+        signal.signal(signal.SIGWINCH, _on_resize)
+    except Exception:
+        pass
 
-    recv_thread = threading.Thread(target=_recv_loop, daemon=True)
-    recv_thread.start()
+    t = threading.Thread(target=_stdin_pump, daemon=True)
+    t.start()
 
-    def _flush_queue(timeout: float = 30.0) -> tuple[list[str], int, str]:
-        """Collect stdout/stderr until exit frame.  Returns (lines, code, new_cwd)."""
-        lines: list[str] = []
-        ec = 0
-        new_cwd = cwd
-        deadline = time.time() + timeout
-        while time.time() < deadline:
+    # ── Main loop: WS → local stdout (raw PTY output) ────────────────────────
+    try:
+        while True:
             try:
-                raw = q.get(timeout=0.05)
-            except _q.Empty:
-                continue
-            if raw is None:
+                raw = ws.recv()
+            except Exception:
                 break
             try:
                 frame = json.loads(raw)
             except Exception:
                 continue
-            ft = frame.get("type")
-            if ft in ("stdout", "pty_out"):
-                chunk = base64.b64decode(frame.get("data", ""))
-                # Strip ANSI, split into lines for inset display
-                text = chunk.decode("utf-8", errors="replace")
-                # Remove ANSI escape codes for clean inset display
-                import re as _re
-                text = _re.sub(r'\x1b\[[0-9;]*[mGKHF]', '', text)
-                text = _re.sub(r'\x1b\][^\x07]*\x07', '', text)
-                for ln in text.splitlines():
-                    if ln.strip():
-                        lines.append(ln)
-            elif ft == "exit":
-                ec = frame.get("code", 0)
-                new_cwd = frame.get("cwd", cwd)
+            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','?')}\r\n",
+                      file=sys.stderr, flush=True)
+                exit_code = 1
                 break
-            elif ft == "error":
-                lines.append(f"{_R}error:{_RS} {frame.get('message','?')}")
-                ec = 1
+            elif ftype == "disconnected":
+                stop.set()
                 break
-            elif ft == "ping":
+            elif ftype == "ping":
                 try:
                     ws.send(json.dumps({"type": "pong"}))
                 except Exception:
-                    pass
-        return lines, ec, new_cwd
-
-    # ── Session banner ────────────────────────────────────────────────────────
-    print()
-    print(f"  {_G}◉{_RS}  {_C}akash shell{_RS}  {_DM}code {code}  ·  :help for commands  ·  :exit to quit{_RS}")
-    print()
-
-    # ── REPL loop ─────────────────────────────────────────────────────────────
-    last_cmd = ""
-    try:
-        while True:
-            _sh_draw_header(identity, cwd)
-            try:
-                cmd = input(_sh_input_prompt()).strip()
-            except (EOFError, KeyboardInterrupt):
-                print()
-                break
-
-            if not cmd:
-                continue
-
-            # ── Built-in commands ─────────────────────────────────────────────
-            if cmd == ":exit" or cmd == "exit":
-                break
-            if cmd == ":clear" or cmd == "clear":
-                print("\033[2J\033[H", end="", flush=True)
-                continue
-            if cmd == ":help":
-                _sh_help()
-                continue
-            if cmd == ":h":
-                _sh_history(history)
-                continue
-            if cmd == ":status":
-                _sh_status(code, cwd, history)
-                continue
-            if cmd == ":r":
-                if not last_cmd:
-                    print(f"  {_Y}!{_RS}  no previous command\n")
-                    continue
-                cmd = last_cmd
-                print(f"  {_DM}re-running:{_RS} {cmd}")
-            if cmd.startswith(":upload "):
-                fpath = cmd[8:].strip()
-                _p = print
-                _p(f"  {_DM}uploading {fpath}…{_RS}")
-                try:
-                    from .client import AkashClient
-                    import os as _os
-                    cfg = __import__("akashcli.config", fromlist=["ConfigManager"]).ConfigManager
-                    _cfg = cfg.load()
-                    api_key = _os.getenv("AKASH_API_KEY") or _cfg.get("api_key")
-                    if not api_key:
-                        print(f"  {_R}✗{_RS}  no API key — run akash login first\n")
-                        continue
-                    client = AkashClient(api_key=api_key)
-                    result = client.upload_file(fpath)
-                    print(f"  {_G}✓{_RS}  uploaded  {_C}{result.file_code}{_RS}  {_DM}{result.url}{_RS}\n")
-                except Exception as ue:
-                    print(f"  {_R}✗{_RS}  upload failed: {ue}\n")
-                continue
-
-            # ── Remote command ────────────────────────────────────────────────
-            history.append(cmd)
-            last_cmd = cmd
-            try:
-                _rl.add_history(cmd)
-            except Exception:
-                pass
-
-            t0 = time.monotonic()
-            # Send as `run` — host device executes via bash and streams stdout back.
-            # We always prefix with `cd <cwd>` so state persists across commands.
-            # For `cd` commands we also capture $PWD to update our local cwd tracker.
-            if cmd.startswith("cd ") or cmd == "cd":
-                # Run cd inside current cwd, then print new $PWD as sentinel
-                actual_cmd = (
-                    f'cd {json.dumps(cwd)} 2>/dev/null; '
-                    f'{cmd}; '
-                    f'echo "__AKASH_CWD__:$PWD"'
-                )
-            else:
-                actual_cmd = (
-                    f'cd {json.dumps(cwd)} 2>/dev/null && '
-                    f'{{ {cmd}; }}; '
-                    f'echo "__AKASH_EXIT__:$?"'
-                )
-
-            try:
-                ws.send(json.dumps({"type": "run", "command": actual_cmd}))
-            except Exception:
-                print(f"\n  {_R}✗{_RS}  disconnected\n")
-                break
-
-            lines, ec, _ = _flush_queue()
-            elapsed_ms = (time.monotonic() - t0) * 1000
-
-            # Parse cwd tracking lines out of output
-            clean_lines = []
-            for ln in lines:
-                if ln.startswith("__AKASH_CWD__:"):
-                    cwd = ln[len("__AKASH_CWD__:"):].strip() or cwd
-                elif ln.startswith("__AKASH_EXIT__:"):
-                    try:
-                        ec = int(ln[len("__AKASH_EXIT__:"):].strip())
-                    except Exception:
-                        pass
-                else:
-                    clean_lines.append(ln)
-
-            exit_code = ec
-
-            if clean_lines:
-                _sh_inset(clean_lines)
-            else:
-                print()
-            _sh_footer(ec, elapsed_ms)
-
-    except Exception:
+                    break
+    except KeyboardInterrupt:
         pass
     finally:
-        stop_recv.set()
+        stop.set()
+        _restore()
         try:
-            ws.send(json.dumps({"type": "close"}))
+            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
         except Exception:
             pass
         try:
-            ws.close()
+            ws.send(json.dumps({"type": "close"}))
         except Exception:
             pass
         try:
-            _rl.write_history_file(str(hist_file))
+            ws.close()
         except Exception:
             pass
 
+    # Print a clean newline after raw mode ends
+    print(f"\r\n  {_DM}session ended  code {exit_code}{_RS}\r\n", flush=True)
     return exit_code

{akashcli-4.5.8 → akashcli-4.6.0}/akashcli.egg-info/PKG-INFO

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

{akashcli-4.5.8 → akashcli-4.6.0}/pyproject.toml

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