akashcli 4.5.7__tar.gz → 4.5.8__tar.gz

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

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

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

@@ -222,21 +222,7 @@ def _handle_pty(ws, frame: dict) -> None:
     import subprocess as _sp
     shell = command or os.environ.get("SHELL", "/bin/bash")
 
-    # DevOS-style PS1 injected into every relay shell session.
-    # Uses only bash builtins + git (optional). No external deps.
-    _AKASH_PS1 = (
-        r'__akash_ps1() { '
-        r'  local b; b=$(git branch --show-current 2>/dev/null); '
-        r'  [ -n "$b" ] && echo -e " \033[90m(\033[1;35m$b\033[90m)\033[0m"; '
-        r'}; '
-        r'PS1="\n\033[1;36m╭─\033[0m \033[1;32m\u\033[90m@\033[1;32m\h\033[0m'
-        r'  \033[1;34m\w\033[0m\$(__akash_ps1)\n'
-        r'\033[1;36m╰─❯\033[0m "; '
-        r'export PS1'
-    )
-
-    # Run the shell directly (not wrapped in bash -c) so it IS the login shell
-    # and gets a proper controlling terminal from slave_fd.
+    # Run the shell directly so it gets a proper controlling terminal.
     try:
         proc = _sp.Popen(
             [shell],
@@ -258,14 +244,6 @@ def _handle_pty(ws, frame: dict) -> None:
 
     os.close(slave_fd)
 
-    # Give bash ~120 ms to finish sourcing .bashrc, then inject our PS1.
-    import time as _time
-    _time.sleep(0.12)
-    try:
-        os.write(master_fd, (_AKASH_PS1 + "\n").encode())
-    except Exception:
-        pass
-
     stop = threading.Event()
 
     # Thread: master fd → WebSocket  (drain as fast as possible)
@@ -711,175 +689,374 @@ def guest_serve(base_url: str) -> None:
             time.sleep(3)
 
 
+# ── DevOS-style shell UI ──────────────────────────────────────────────────────
+
+_SH_C  = "\033[1;36m"    # cyan bold   (border, ╭╰)
+_SH_W  = "\033[1;37m"    # white bold  (identity)
+_SH_G  = "\033[1;32m"    # green bold  (ok exit)
+_SH_R  = "\033[1;31m"    # red bold    (error exit)
+_SH_Y  = "\033[1;33m"    # yellow bold (git branch)
+_SH_DM = "\033[2m"       # dim         (timing, path)
+_SH_GR = "\033[90m"      # gray        (│ border, separators)
+_SH_RS = "\033[0m"       # reset
+
+
+def _sh_sanitize_path(path: str, maxlen: int = 34) -> str:
+    home = os.path.expanduser("~")
+    if path == home:
+        return "~"
+    if path.startswith(home + "/"):
+        path = "~" + path[len(home):]
+    if len(path) <= maxlen:
+        return path
+    parts = path.split("/")
+    tail = parts[-1]
+    mid  = parts[-2] if len(parts) >= 2 else ""
+    return f".../{mid}/{tail}" if mid else f".../{tail}"
+
+
+def _sh_git_branch(cwd: str) -> str:
+    """Read git branch from .git/HEAD — no subprocess, pure Python."""
+    d = cwd
+    while d and d != "/":
+        head = os.path.join(d, ".git", "HEAD")
+        if os.path.isfile(head):
+            try:
+                line = open(head).readline().strip()
+                if line.startswith("ref: refs/heads/"):
+                    return line[len("ref: refs/heads/"):]
+                return line[:7]
+            except Exception:
+                return ""
+        d = os.path.dirname(d)
+    return ""
+
+
+def _sh_draw_header(identity: str, cwd: str) -> None:
+    path   = _sh_sanitize_path(cwd)
+    branch = _sh_git_branch(cwd)
+    branch_part = (
+        f"  {_SH_GR}({_SH_Y}{branch}{_SH_GR}){_SH_RS}" if branch else ""
+    )
+    print(
+        f"{_SH_C}╭─{_SH_RS} {_SH_W}{identity}{_SH_RS} "
+        f"{_SH_GR}•{_SH_RS} {_SH_DM}{path}{_SH_RS}"
+        f"{branch_part}"
+    )
+
+
+def _sh_input_prompt() -> str:
+    return f"{_SH_C}╰─{_SH_RS} {_SH_W}${_SH_RS} "
+
+
+def _sh_footer(ec: int, elapsed_ms: float) -> None:
+    color = _SH_G if ec == 0 else _SH_R
+    t = f"  {_SH_GR}{elapsed_ms/1000:.2f}s{_SH_RS}" if elapsed_ms >= 100 else ""
+    print(f"  {_SH_GR}•{_SH_RS} {color}[{ec}]{_SH_RS}{t}")
+    print()
+
+
+def _sh_inset(lines: list[str]) -> None:
+    print()
+    for line in lines:
+        print(f"  {_SH_GR}│{_SH_RS} {line}")
+    print(f"  {_SH_GR}│{_SH_RS}")
+
+
+def _sh_help() -> None:
+    print()
+    print(f"  {_SH_GR}╭─ AKASH SHELL COMMANDS{_SH_RS}")
+    cmds = [
+        (":h",        "session history"),
+        (":r",        "re-run last command"),
+        (":clear",    "clear screen"),
+        (":status",   "show session info"),
+        (":upload F", "upload local file F to vault"),
+        (":exit",     "disconnect"),
+    ]
+    for cmd, desc in cmds:
+        print(f"  {_SH_GR}│{_SH_RS}  {_SH_C}{cmd:<12}{_SH_RS}  {_SH_DM}{desc}{_SH_RS}")
+    print(f"  {_SH_GR}╰─{_SH_RS}")
+    print()
+
+
+def _sh_status(code: str, cwd: str, history: list) -> None:
+    print()
+    print(f"  {_SH_GR}╭─ SESSION{_SH_RS}")
+    print(f"  {_SH_GR}│{_SH_RS}  code      {_SH_C}{code}{_SH_RS}")
+    print(f"  {_SH_GR}│{_SH_RS}  cwd       {_SH_DM}{cwd}{_SH_RS}")
+    print(f"  {_SH_GR}│{_SH_RS}  history   {len(history)} commands")
+    print(f"  {_SH_GR}╰─{_SH_RS}")
+    print()
+
+
+def _sh_history(history: list) -> None:
+    print()
+    if not history:
+        print(f"  {_SH_GR}│{_SH_RS}  (no commands yet)")
+    else:
+        start = max(0, len(history) - 15)
+        for i, cmd in enumerate(history[start:], start + 1):
+            print(f"  {_SH_GR}│{_SH_RS}  {_SH_DM}{i:>3}{_SH_RS}  {cmd}")
+    print(f"  {_SH_GR}│{_SH_RS}")
+    print()
+
+
 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.
+    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.
     """
-    import select as _sel, signal
+    import readline as _rl
+    import queue as _q
 
     code = code.strip().upper()
     ws_url = _guest_join_url(base_url, code)
 
-    from .exec import _get_terminal_size
-    rows, cols = _get_terminal_size()
+    # ── Connect & handle approval ─────────────────────────────────────────────
+    print(f"\n  {_C}◈{_RS}  {_DM}connecting…{_RS}")
+    try:
+        ws = _ws_connect(ws_url, open_timeout=15, close_timeout=10)
+    except Exception as e:
+        raise RuntimeError(str(e))
 
-    _raw_ok = False
-    _old_settings = None
-    _stdin_fd = -1
+    first = json.loads(ws.recv())
+    ftype = first.get("type")
+
+    if ftype == "error":
+        ws.close()
+        raise RuntimeError(first.get("message", "relay error"))
+
+    if ftype == "waiting_approval":
+        fp = first.get("fingerprint", "")
+        print(f"  {_C}◈{_RS}  {_DM}waiting for host to approve…{_RS}")
+        if fp:
+            print(f"  {_DM}fingerprint  {_C}{fp}{_SH_RS}")
+        print(f"  {_DM}host has 30 s to respond{_RS}\n")
+        try:
+            second = json.loads(ws.recv(timeout=35))
+        except Exception:
+            ws.close()
+            raise RuntimeError("Timed out waiting for host approval.")
+        if second.get("type") == "denied":
+            ws.close()
+            raise RuntimeError("Host declined the connection.")
+        if second.get("type") != "connected":
+            ws.close()
+            raise RuntimeError(second.get("message", "unexpected response from host"))
+    elif ftype != "connected":
+        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"
+
+    # readline history setup
+    hist_file = _AKASH_DIR / "shell_history"
+    _AKASH_DIR.mkdir(parents=True, exist_ok=True)
     try:
-        import tty, termios as _term
-        _stdin_fd = sys.stdin.fileno()
-        _old_settings = _term.tcgetattr(_stdin_fd)
-        tty.setraw(_stdin_fd)
-        _raw_ok = True
+        _rl.read_history_file(str(hist_file))
     except Exception:
         pass
+    _rl.set_history_length(500)
 
-    def _restore():
-        if _raw_ok and _old_settings is not None:
+    # ── Output queue — background thread feeds frames ─────────────────────────
+    q: _q.Queue = _q.Queue()
+    stop_recv = threading.Event()
+
+    def _recv_loop():
+        while not stop_recv.is_set():
             try:
-                import termios as _t
-                _t.tcsetattr(_stdin_fd, _t.TCSADRAIN, _old_settings)
+                raw = ws.recv(timeout=0.1)
+                q.put(raw)
             except Exception:
-                pass
+                if not stop_recv.is_set():
+                    q.put(None)   # signals disconnection
+                break
 
-    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")
+    recv_thread = threading.Thread(target=_recv_loop, daemon=True)
+    recv_thread.start()
 
-            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"\n  {_C}◈{_RS}  {_DM}waiting for host to approve…{_RS}")
-                if fp:
-                    print(f"  {_DM}fingerprint  {_C}{fp}{_RS}")
-                print(f"  {_DM}host has 30 s to respond{_RS}\n")
-                # 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
+    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:
+            try:
+                raw = q.get(timeout=0.05)
+            except _q.Empty:
+                continue
+            if raw is None:
+                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)
+                break
+            elif ft == "error":
+                lines.append(f"{_R}error:{_RS} {frame.get('message','?')}")
+                ec = 1
+                break
+            elif ft == "ping":
                 try:
-                    import tty as _tty2, termios as _term2
-                    _old_settings = _term2.tcgetattr(_stdin_fd)
-                    _tty2.setraw(_stdin_fd)
-                    _raw_ok = True
+                    ws.send(json.dumps({"type": "pong"}))
                 except Exception:
                     pass
-            elif ftype != "connected":
-                _restore()
-                raise RuntimeError(first.get("message", "unexpected server response"))
+        return lines, ec, new_cwd
 
-            # Print a clean DevOS-style session header before entering raw mode
-            _restore()
-            print(f"\n  {_G}◉{_RS}  {_C}akash shell{_RS}  {_DM}·  code {code}  ·  Ctrl-C to disconnect{_RS}\n")
-            # Re-enter raw mode
-            try:
-                import tty as _tty3, termios as _term3
-                _old_settings = _term3.tcgetattr(_stdin_fd)
-                _tty3.setraw(_stdin_fd)
-                _raw_ok = True
-            except Exception:
-                pass
+    # ── Session banner ────────────────────────────────────────────────────────
+    print()
+    print(f"  {_G}◉{_RS}  {_C}akash shell{_RS}  {_DM}code {code}  ·  :help for commands  ·  :exit to quit{_RS}")
+    print()
 
-            ws.send(json.dumps({
-                "type": "pty_run",
-                "command": os.environ.get("SHELL", "/bin/bash"),
-                "rows": rows, "cols": cols,
-            }))
+    # ── REPL loop ─────────────────────────────────────────────────────────────
+    last_cmd = ""
+    try:
+        while True:
+            _sh_draw_header(identity, cwd)
+            try:
+                cmd = input(_sh_input_prompt()).strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                break
 
-            stop = threading.Event()
+            if not cmd:
+                continue
 
-            def _stdin_pump():
+            # ── 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:
-                    while not stop.is_set():
-                        if _stdin_fd >= 0:
-                            r = _sel.select([_stdin_fd], [], [], 0.02)[0]
-                            if not r:
-                                continue
-                            # Read up to 4 KiB — handles paste bursts snappily
-                            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
+                    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
 
-            def _on_resize(signum, _frame):
-                r, c = _get_terminal_size()
-                try:
-                    ws.send(json.dumps({"type": "resize", "rows": r, "cols": c}))
-                except Exception:
-                    pass
+            # ── Remote command ────────────────────────────────────────────────
+            history.append(cmd)
+            last_cmd = cmd
             try:
-                signal.signal(signal.SIGWINCH, _on_resize)
+                _rl.add_history(cmd)
             except Exception:
                 pass
 
-            t = threading.Thread(target=_stdin_pump, daemon=True)
-            t.start()
+            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__:$?"'
+                )
 
-            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": "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:
-                        ws.send(json.dumps({"type": "pong"}))
+                        ec = int(ln[len("__AKASH_EXIT__:"):].strip())
                     except Exception:
-                        break
+                        pass
+                else:
+                    clean_lines.append(ln)
 
-    except KeyboardInterrupt:
+            exit_code = ec
+
+            if clean_lines:
+                _sh_inset(clean_lines)
+            else:
+                print()
+            _sh_footer(ec, elapsed_ms)
+
+    except Exception:
         pass
     finally:
-        stop.set() if 'stop' in dir() else None
-        _restore()
+        stop_recv.set()
         try:
-            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+            ws.send(json.dumps({"type": "close"}))
+        except Exception:
+            pass
+        try:
+            ws.close()
+        except Exception:
+            pass
+        try:
+            _rl.write_history_file(str(hist_file))
         except Exception:
             pass
 

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

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

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

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