akashcli 4.6.2__tar.gz → 4.6.3__tar.gz

{akashcli-4.6.2 → akashcli-4.6.3}/PKG-INFO

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

{akashcli-4.6.2 → akashcli-4.6.3}/akashcli/relay.py

@@ -164,30 +164,68 @@ def _run_relay_device(ws, label: str) -> None:
 
 
 def _handle_run(ws, frame: dict) -> None:
-    """Execute a non-interactive command and stream output back."""
+    """Execute a non-interactive command, stream output in real-time, send cwd."""
     import subprocess as _sp
+    import select as _sel
+
+    command  = frame.get("command", "")
+    cwd      = frame.get("cwd", os.path.expanduser("~"))
+    env      = {**os.environ, "TERM": "dumb"}
 
-    command = frame.get("command", "")
     try:
         proc = _sp.Popen(
             command, shell=True,
             stdout=_sp.PIPE, stderr=_sp.STDOUT,
-            cwd=os.path.expanduser("~"),
+            cwd=cwd,
+            env=env,
         )
+        fd = proc.stdout.fileno()
+        # Non-blocking read: send chunks as soon as they arrive
         while True:
-            chunk = proc.stdout.read(4096)
-            if not chunk:
+            r, _, _ = _sel.select([fd], [], [], 0.02)
+            if r:
+                chunk = os.read(fd, 16384)
+                if not chunk:
+                    break
+                ws.send(json.dumps({
+                    "type": "stdout",
+                    "data": base64.b64encode(chunk).decode(),
+                }))
+            elif proc.poll() is not None:
+                # Drain any remaining bytes
+                try:
+                    while True:
+                        r2, _, _ = _sel.select([fd], [], [], 0)
+                        if not r2:
+                            break
+                        chunk = os.read(fd, 16384)
+                        if not chunk:
+                            break
+                        ws.send(json.dumps({
+                            "type": "stdout",
+                            "data": base64.b64encode(chunk).decode(),
+                        }))
+                except Exception:
+                    pass
                 break
-            ws.send(json.dumps({
-                "type": "stdout",
-                "data": base64.b64encode(chunk).decode(),
-            }))
         proc.wait()
-        ws.send(json.dumps({"type": "exit", "code": proc.returncode or 0}))
+        # Resolve final cwd: try to read it from the shell
+        try:
+            result = _sp.run(
+                ["sh", "-c", f"cd {json.dumps(cwd)} 2>/dev/null; true"],
+                capture_output=True, timeout=1,
+            )
+        except Exception:
+            pass
+        ws.send(json.dumps({
+            "type": "exit",
+            "code": proc.returncode or 0,
+            "cwd":  cwd,
+        }))
     except Exception as e:
         try:
             ws.send(json.dumps({"type": "error", "message": str(e)}))
-            ws.send(json.dumps({"type": "exit",  "code": 1}))
+            ws.send(json.dumps({"type": "exit",  "code": 1, "cwd": cwd}))
         except Exception:
             pass
 
@@ -796,15 +834,19 @@ 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"),
+        (":help / :h",  "this help"),
+        (":hist",       "command history"),
+        (":clear",      "clear screen"),
+        (":status",     "session info (code, cwd)"),
+        (":pty [cmd]",  "run cmd in full PTY mode (for nano, vim, htop…)"),
+        (":upload F",   "upload local file F to vault"),
+        (":exit",       "disconnect"),
+        ("exit / Ctrl-D", "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}  {_SH_C}{cmd:<18}{_SH_RS}  {_SH_DM}{desc}{_SH_RS}")
+    print(f"  {_SH_GR}│{_SH_RS}")
+    print(f"  {_SH_GR}│{_SH_RS}  {_SH_DM}TUI apps (nano, vim, htop, python3…) auto-switch to PTY{_SH_RS}")
     print(f"  {_SH_GR}╰─{_SH_RS}")
     print()
 
@@ -831,21 +873,96 @@ def _sh_history(history: list) -> None:
     print()
 
 
+# ── TUI apps that always get PTY mode ────────────────────────────────────────
+_PTY_APPS = frozenset({
+    "nano", "vim", "vi", "nvim", "emacs", "pico",
+    "htop", "top", "btop", "less", "more", "man",
+    "python", "python3", "ipython", "node", "irb",
+    "mysql", "psql", "sqlite3", "mongo",
+    "bash", "sh", "zsh", "fish", "ksh",
+    "watch", "screen", "tmux",
+    "fzf", "ranger", "mc", "nnn",
+    "ssh", "telnet",
+})
+
+
+def _is_pty_cmd(cmd: str) -> bool:
+    """Return True if cmd should run in PTY mode (TUI / interactive app)."""
+    first = cmd.strip().lstrip("\\").split()[0] if cmd.strip() else ""
+    # strip path — /usr/bin/vim → vim
+    first = first.split("/")[-1]
+    return first in _PTY_APPS
+
+
+def _term_cols() -> int:
+    try:
+        import shutil as _s
+        return _s.get_terminal_size(fallback=(80, 24)).columns
+    except Exception:
+        return 80
+
+
+def _term_size() -> tuple:
+    try:
+        import shutil as _s
+        ts = _s.get_terminal_size(fallback=(80, 24))
+        return ts.lines, ts.columns
+    except Exception:
+        return 24, 80
+
+
+def _strip_ansi(text: str) -> str:
+    import re
+    text = re.sub(r'\x1b\[[0-9;]*[mGKHFJA-Za-z]', '', text)
+    text = re.sub(r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)', '', text)
+    return text
+
+
+def _print_output(lines: list, cols: int) -> None:
+    """Print command output with inset │ borders, wrapping long lines."""
+    GR, RS = _SH_GR, _SH_RS
+    # wrap at cols - 6 (accounts for "  │ " prefix)
+    wrap = max(cols - 6, 40)
+    printed = 0
+    MAX = 200
+    for raw_line in lines:
+        # wrap long lines
+        while len(raw_line) > wrap:
+            sys.stdout.write(f"  {GR}│{RS} {raw_line[:wrap]}\n")
+            raw_line = raw_line[wrap:]
+            printed += 1
+            if printed >= MAX:
+                break
+        if printed >= MAX:
+            remaining = len(lines) - lines.index(raw_line)
+            sys.stdout.write(f"  {GR}│{RS} {_SH_DM}… {remaining} more lines{RS}\n")
+            break
+        sys.stdout.write(f"  {GR}│{RS} {raw_line}\n")
+        printed += 1
+    sys.stdout.flush()
+
+
 def guest_connect_shell(base_url: str, code: str) -> int:
     """
     Connect to a guest host via pairing 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.
+
+    Dual-mode interactive shell:
+      REPL mode  — DevOS prompt, commands run via `run` frames, real-time
+                   streaming output with │ borders. Fast, clean, readable.
+      PTY mode   — auto-switched for TUI apps (nano/vim/htop/etc.) or on
+                   demand with :pty. Terminal goes raw, full escape codes.
+
+    Returns the last remote exit code.
     """
+    import queue as _q
     import select as _sel
     import signal
+    import shutil as _sh
 
     code = code.strip().upper()
     ws_url = _guest_join_url(base_url, code)
 
-    # ── Connect & handle approval (before entering raw mode) ─────────────────
+    # ── 1. Connect ────────────────────────────────────────────────────────────
     print(f"\n  {_C}◈{_RS}  {_DM}connecting…{_RS}", flush=True)
     try:
         ws = _ws_connect(ws_url, open_timeout=15, close_timeout=10)
@@ -880,145 +997,394 @@ def guest_connect_shell(base_url: str, code: str) -> int:
         ws.close()
         raise RuntimeError(first.get("message", "unexpected server response"))
 
-    # ── 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)
+    # ── 2. Session state ──────────────────────────────────────────────────────
+    identity  = os.environ.get("USER") or os.environ.get("LOGNAME") or "akash"
+    cwd       = "~"          # updated from exit frames
+    history   : list[str] = []
+    exit_code = 0
 
-    # ── Get terminal size ─────────────────────────────────────────────────────
+    # readline history
+    _AKASH_DIR.mkdir(parents=True, exist_ok=True)
+    hist_file = _AKASH_DIR / "shell_history"
     try:
-        import shutil as _sh
-        cols, rows = _sh.get_terminal_size(fallback=(80, 24))
+        import readline as _rl
+        _rl.read_history_file(str(hist_file))
+        _rl.set_history_length(500)
     except Exception:
-        rows, cols = 24, 80
+        _rl = None  # type: ignore
 
-    # ── Enter raw mode ────────────────────────────────────────────────────────
-    _raw_ok = False
+    # ── 3. Background recv thread → queue ─────────────────────────────────────
+    # Feeds all incoming WS frames into a queue so the REPL loop
+    # can collect them without blocking the main thread on ws.recv().
+    _q_frames: _q.Queue = _q.Queue()
+    _stop_recv = threading.Event()
+
+    def _recv_worker():
+        while not _stop_recv.is_set():
+            try:
+                raw = ws.recv(timeout=1.0)
+                _q_frames.put(raw)
+            except Exception as exc:
+                if not _stop_recv.is_set():
+                    _q_frames.put(None)   # sentinel: disconnected
+                break
+
+    _recv_t = threading.Thread(target=_recv_worker, daemon=True)
+    _recv_t.start()
+
+    # ── 4. Banner ─────────────────────────────────────────────────────────────
+    print(f"\n  {_G}◉{_RS}  {_C}akash shell{_RS}  "
+          f"{_DM}code {_C}{code}{_DM}  ·  :help for commands{_RS}\n",
+          flush=True)
+
+    # ── helpers for raw / PTY mode ─────────────────────────────────────────────
+    _stdin_fd     = -1
+    _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 _restore():
+    def _enter_raw():
+        nonlocal _stdin_fd, _raw_ok, _old_settings
+        try:
+            import tty as _tty, termios as _tm
+            _stdin_fd     = sys.stdin.fileno()
+            _old_settings = _tm.tcgetattr(_stdin_fd)
+            _tty.setraw(_stdin_fd)
+            _raw_ok = True
+        except Exception:
+            pass
+
+    def _leave_raw():
         if _raw_ok and _old_settings is not None:
             try:
-                import termios as _t
-                _t.tcsetattr(_stdin_fd, _t.TCSADRAIN, _old_settings)
+                import termios as _tm2
+                _tm2.tcsetattr(_stdin_fd, _tm2.TCSADRAIN, _old_settings)
             except Exception:
                 pass
 
-    exit_code = 0
-    stop = threading.Event()
+    # ── PTY passthrough session ───────────────────────────────────────────────
+    def _run_pty(cmd: str) -> int:
+        """
+        Enter raw mode, send pty_run to host, bridge I/O until exit frame.
+        Returns exit code.  Restores terminal on return.
+        """
+        rows, cols = _term_size()
+        _enter_raw()
+        _pty_stop = threading.Event()
+
+        # SIGWINCH → resize
+        def _on_resize(sig, _f):
+            try:
+                r2, c2 = _term_size()
+                ws.send(json.dumps({"type": "resize", "rows": r2, "cols": c2}))
+            except Exception:
+                pass
+        try:
+            signal.signal(signal.SIGWINCH, _on_resize)
+        except Exception:
+            pass
 
-    # ── 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}")
+        # stdin pump
+        def _pump():
+            try:
+                while not _pty_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
 
-    # ── 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:
+            ws.send(json.dumps({
+                "type":    "pty_run",
+                "command": cmd or os.environ.get("SHELL", "/bin/bash"),
+                "rows":    rows,
+                "cols":    cols,
+            }))
+        except Exception as e:
+            _leave_raw()
+            print(f"\r\n  {_R}✗{_RS}  {e}\r\n", flush=True)
+            return 1
+
+        pump_t = threading.Thread(target=_pump, daemon=True)
+        pump_t.start()
+
+        ec = 0
+        try:
+            while True:
+                try:
+                    raw = _q_frames.get(timeout=0.05)
+                except _q.Empty:
+                    continue
+                if raw is None:
                     break
-                ws.send(json.dumps({
-                    "type": "pty_in",
-                    "data": base64.b64encode(chunk).decode(),
-                }))
-        except Exception:
+                try:
+                    frame = json.loads(raw)
+                except Exception:
+                    continue
+                ft = frame.get("type")
+                if ft == "pty_out":
+                    data = base64.b64decode(frame["data"])
+                    if data:
+                        sys.stdout.buffer.write(data)
+                        sys.stdout.buffer.flush()
+                elif ft == "exit":
+                    ec = frame.get("code", 0)
+                    break
+                elif ft == "error":
+                    _leave_raw()
+                    print(f"\r\n  {_R}[error]{_RS} {frame.get('message','?')}\r\n",
+                          flush=True)
+                    ec = 1
+                    break
+                elif ft == "disconnected":
+                    break
+                elif ft == "ping":
+                    try:
+                        ws.send(json.dumps({"type": "pong"}))
+                    except Exception:
+                        break
+        except KeyboardInterrupt:
             pass
+        finally:
+            _pty_stop.set()
+            try:
+                signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+            except Exception:
+                pass
 
-    # ── SIGWINCH → resize frame ───────────────────────────────────────────────
-    def _on_resize(signum, _frame):
+        _leave_raw()
+        print(flush=True)    # clean line after PTY output
+        return ec
+
+    # ── REPL command runner ───────────────────────────────────────────────────
+    def _run_cmd(cmd: str) -> tuple:
+        """
+        Send `run` frame, collect stdout in real-time, return (lines, ec, new_cwd).
+        Output is printed live as │ lines while collecting for the footer.
+        """
+        # Wrap: cd to cwd, run command, emit sentinels
+        actual = (
+            f'cd {json.dumps(cwd)} 2>/dev/null\n'
+            f'{cmd}\n'
+            f'printf "\\x00__EC__%d\\x00" "$?"\n'
+            f'printf "\\x00__CWD__%s\\x00" "$PWD"\n'
+        )
         try:
-            import shutil as _sh2
-            c2, r2 = _sh2.get_terminal_size(fallback=(80, 24))
-            ws.send(json.dumps({"type": "resize", "rows": r2, "cols": c2}))
+            ws.send(json.dumps({
+                "type":    "run",
+                "command": actual,
+                "cwd":     cwd,
+            }))
         except Exception:
-            pass
-    try:
-        signal.signal(signal.SIGWINCH, _on_resize)
-    except Exception:
-        pass
+            return [], 1, cwd
 
-    t = threading.Thread(target=_stdin_pump, daemon=True)
-    t.start()
+        cols       = _term_cols()
+        buf        = b""
+        lines      : list[str] = []
+        ec         = 0
+        new_cwd    = cwd
+        deadline   = time.time() + 60.0
+        started    = False
 
-    # ── Main loop: WS → local stdout (raw PTY output) ────────────────────────
-    try:
-        while True:
+        while time.time() < deadline:
             try:
-                raw = ws.recv()
-            except Exception:
+                raw = _q_frames.get(timeout=0.05)
+            except _q.Empty:
+                continue
+            if raw is None:
                 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','?')}\r\n",
-                      file=sys.stderr, flush=True)
-                exit_code = 1
+            ft = frame.get("type")
+
+            if ft == "stdout":
+                chunk = base64.b64decode(frame.get("data", ""))
+                buf  += chunk
+                # Print lines as they arrive — real-time streaming
+                while b"\n" in buf:
+                    line_b, buf = buf.split(b"\n", 1)
+                    line = _strip_ansi(line_b.decode("utf-8", errors="replace"))
+                    # Parse null-delimited sentinels
+                    if "\x00__EC__" in line:
+                        import re as _re
+                        m = _re.search(r'\x00__EC__(\d+)\x00', line)
+                        if m:
+                            ec = int(m.group(1))
+                        continue
+                    if "\x00__CWD__" in line:
+                        import re as _re
+                        m = _re.search(r'\x00__CWD__([^\x00]+)\x00', line)
+                        if m:
+                            new_cwd = m.group(1).strip()
+                        continue
+                    if not started:
+                        # Print blank separator before first output line
+                        sys.stdout.write("\n")
+                        started = True
+                    # Print live
+                    display = line.rstrip()
+                    # wrap
+                    wrap = max(cols - 6, 40)
+                    while len(display) > wrap:
+                        sys.stdout.write(f"  {_SH_GR}│{_SH_RS} {display[:wrap]}\n")
+                        display = display[wrap:]
+                    sys.stdout.write(f"  {_SH_GR}│{_SH_RS} {display}\n")
+                    sys.stdout.flush()
+                    lines.append(line.rstrip())
+
+            elif ft == "exit":
+                ec      = frame.get("code", ec)
+                new_cwd = frame.get("cwd",  new_cwd) or new_cwd
+                # Flush remaining buffer
+                if buf:
+                    line = _strip_ansi(buf.decode("utf-8", errors="replace")).rstrip()
+                    if line and "\x00__EC__" not in line and "\x00__CWD__" not in line:
+                        if not started:
+                            sys.stdout.write("\n")
+                            started = True
+                        sys.stdout.write(f"  {_SH_GR}│{_SH_RS} {line}\n")
+                        sys.stdout.flush()
+                        lines.append(line)
                 break
-            elif ftype == "disconnected":
-                stop.set()
+
+            elif ft == "error":
+                msg = frame.get("message", "?")
+                if not started:
+                    sys.stdout.write("\n")
+                    started = True
+                sys.stdout.write(f"  {_SH_GR}│{_RS} {_R}error:{_RS} {msg}\n")
+                sys.stdout.flush()
+                lines.append(f"error: {msg}")
+                ec = 1
                 break
-            elif ftype == "ping":
+
+            elif ft == "ping":
                 try:
                     ws.send(json.dumps({"type": "pong"}))
                 except Exception:
-                    break
-    except KeyboardInterrupt:
+                    pass
+
+        return lines, ec, new_cwd
+
+    # ── 5. REPL loop ──────────────────────────────────────────────────────────
+    try:
+        while True:
+            # Draw prompt
+            _sh_draw_header(identity, cwd)
+            try:
+                cmd = input(_sh_input_prompt()).strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                break
+
+            if not cmd:
+                continue
+
+            # ── Built-in / local commands ─────────────────────────────────
+            if cmd in (":exit", "exit", "logout"):
+                break
+
+            if cmd in (":clear", "clear"):
+                sys.stdout.write("\033[2J\033[H")
+                sys.stdout.flush()
+                continue
+
+            if cmd in (":help", ":h", "help"):
+                _sh_help()
+                continue
+
+            if cmd == ":hist":
+                _sh_history(history)
+                continue
+
+            if cmd == ":status":
+                _sh_status(code, cwd, history)
+                continue
+
+            if cmd.startswith(":upload "):
+                fpath = cmd[8:].strip()
+                print(f"  {_DM}uploading {fpath}…{_RS}", flush=True)
+                try:
+                    from .client import AkashClient
+                    from .config import ConfigManager
+                    _cfg = ConfigManager.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}  {_C}{result.file_code}{_RS}  {_DM}{result.url}{_RS}\n")
+                except Exception as ue:
+                    print(f"  {_R}✗{_RS}  upload failed: {ue}\n")
+                continue
+
+            # :pty [cmd] — force PTY mode
+            if cmd.startswith(":pty"):
+                pty_cmd = cmd[4:].strip() or ""
+                ec = _run_pty(pty_cmd)
+                exit_code = ec
+                _sh_footer(ec, 0)
+                # Refresh cwd after PTY session
+                continue
+
+            # ── Auto PTY for TUI apps ─────────────────────────────────────
+            if _is_pty_cmd(cmd):
+                ec = _run_pty(cmd)
+                exit_code = ec
+                _sh_footer(ec, 0)
+                continue
+
+            # ── Remote REPL command ───────────────────────────────────────
+            history.append(cmd)
+            try:
+                if _rl:
+                    _rl.add_history(cmd)
+            except Exception:
+                pass
+
+            t0 = time.monotonic()
+            _, ec, new_cwd = _run_cmd(cmd)
+            elapsed_ms = (time.monotonic() - t0) * 1000
+
+            if new_cwd and new_cwd != "~":
+                cwd = new_cwd
+
+            exit_code = ec
+            # Separator line + footer
+            sys.stdout.write(f"  {_SH_GR}│{_SH_RS}\n")
+            sys.stdout.flush()
+            _sh_footer(ec, elapsed_ms)
+
+    except Exception:
         pass
     finally:
-        stop.set()
-        _restore()
+        _stop_recv.set()
         try:
-            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+            ws.send(json.dumps({"type": "close"}))
         except Exception:
             pass
         try:
-            ws.send(json.dumps({"type": "close"}))
+            ws.close()
         except Exception:
             pass
         try:
-            ws.close()
+            if _rl:
+                _rl.write_history_file(str(hist_file))
         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)
+    print(f"\n  {_DM}session ended{_RS}\n", flush=True)
     return exit_code

{akashcli-4.6.2 → akashcli-4.6.3}/akashcli.egg-info/PKG-INFO

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

{akashcli-4.6.2 → akashcli-4.6.3}/pyproject.toml

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