akashcli 4.7.5__tar.gz → 4.7.7__tar.gz

{akashcli-4.7.5 → akashcli-4.7.7}/PKG-INFO

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

{akashcli-4.7.5 → akashcli-4.7.7}/akashcli/cli.py

@@ -47,11 +47,12 @@ def _gr(s: str) -> str:          return f"{_GR}{s}{_RS}"
 
 # ── Spinner (single-line, no flicker) ────────────────────────────────────────
 class _Spin:
-    """Minimal inline spinner with instant frame-0 rendering, smooth 350ms visibility, and clean cleanup."""
+    """Minimal inline spinner with instant frame-0 rendering, smooth visibility, and clean cleanup."""
     _FRAMES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
 
-    def __init__(self, label: str, min_seconds: float = 0.35, disabled: bool = False):
+    def __init__(self, label: str, min_seconds: float = 0.35, disabled: bool = False, prefix: str = ""):
         self._label = label
+        self._prefix = prefix
         self._disabled = disabled or (not sys.stdout.isatty())
         self._min_seconds = min_seconds
         self._i = 0
@@ -61,22 +62,28 @@ class _Spin:
 
     def __enter__(self):
         if self._disabled:
+            pfx = self._prefix + "  " if self._prefix else "  "
+            sys.stdout.write(f"{pfx}{_C}▶{_RS}  {_DM}{self._label}…{_RS}\n")
+            sys.stdout.flush()
             return self
         import threading, time
         self._active = True
         self._t0 = time.monotonic()
-        cr = chr(13)
-        sys.stdout.write(cr + "  " + _C + self._FRAMES[0] + _RS + "  " + _DM + self._label + _RS + "  ")
+        pfx = self._prefix + "  " if self._prefix else "  "
+        sys.stdout.write(f"\r{pfx}{_C}{self._FRAMES[0]}{_RS}  {_DM}{self._label}{_RS}  ")
         sys.stdout.flush()
 
         def _spin():
             time.sleep(0.04)
             while self._active:
                 f = self._FRAMES[self._i % len(self._FRAMES)]
-                sys.stdout.write(chr(13) + "  " + _C + f + _RS + "  " + _DM + self._label + _RS + "  ")
+                now = time.monotonic()
+                dur = now - self._t0
+                dur_str = f" {_dim(f'({dur:.1f}s)')}" if dur >= 0.8 else ""
+                sys.stdout.write(f"\r\033[2K{pfx}{_C}{f}{_RS}  {_DM}{self._label}{_RS}{dur_str}  ")
                 sys.stdout.flush()
                 self._i += 1
-                time.sleep(0.07)
+                time.sleep(0.06)
 
         self._thread = threading.Thread(target=_spin, daemon=True)
         self._thread.start()
@@ -89,13 +96,13 @@ class _Spin:
         if self._disabled:
             return
         import time
+        self._active = False
+        if self._thread:
+            self._thread.join(timeout=0.3)
         elapsed = time.monotonic() - self._t0
         if elapsed < self._min_seconds:
             time.sleep(self._min_seconds - elapsed)
-        self._active = False
-        if self._thread:
-            self._thread.join(timeout=0.2)
-        sys.stdout.write(chr(13) + chr(27) + "[2K"); sys.stdout.flush()
+        sys.stdout.write("\r\033[2K")
         sys.stdout.flush()
 
 def _resolve_client(url_override: str = None, require_key: bool = False, silent: bool = False):
@@ -3247,6 +3254,18 @@ def _sanitize_agent_command(cmd: str, scopes: str = "*") -> tuple[bool, str]:
     if not cmd or not cmd.strip(): return False, "Empty command."
     clean_cmd = cmd.strip()
 
+    # Guard against interactive commands that hang waiting for human input in automated agents
+    interactive_patterns = (
+        r"^\s*(nano|vi|vim|htop|top|less|more|man)\b",
+        r"\bgit\s+commit\s*$",
+        r"^\s*python[0-9.]*\s*$",
+        r"^\s*node\s*$",
+        r"^\s*cat\s*$"
+    )
+    for pat in interactive_patterns:
+        if re.search(pat, clean_cmd):
+            return False, "Interactive command requiring terminal input is not supported in automated execution."
+
     # Unconditional critical security guard (Always enforced regardless of scopes)
     for pat, reason in CRITICAL_DENY_PATTERNS:
         if re.search(pat, clean_cmd):
@@ -3420,6 +3439,7 @@ def mcp_serve(
                         args = frame.get("arguments", {})
                         t0 = time.monotonic()
                         now_str = datetime.datetime.now().strftime("%H:%M:%S")
+                        ts_pfx = f"  {_GR}{now_str}{_RS}"
 
                         if t_name == "akash_exec_command":
                             cmd = args.get("command", "")
@@ -3427,7 +3447,7 @@ def mcp_serve(
 
                             is_safe, sec_reason = _sanitize_agent_command(cmd, scopes=cached.get("scopes", "*"))
                             if not is_safe:
-                                print(f"  {_GR}{now_str}{_RS}  {_R}🚨 Blocked{_RS} -> {disp_cmd} {_dim('(' + sec_reason + ')')}")
+                                print(f"{ts_pfx}  {_R}🚨 Blocked{_RS} -> {disp_cmd} {_dim('(' + sec_reason + ')')}")
                                 ws.send(json.dumps({
                                     "type": "tool_response",
                                     "id": call_id,
@@ -3437,23 +3457,42 @@ def mcp_serve(
                                 if any(k in cmd for k in ["touch", "mkdir", "mv", "cp", "sed", ">", ">>", "python", "npm", "pip"]):
                                     _save_undo_checkpoint()
 
-                                # Instant frame-0 animated spinner with timeout protection
+                                # Auto-add non-interactive flags if missing
+                                exec_cmd = cmd
+                                if re.search(r"\bping\s+", exec_cmd) and "-c" not in exec_cmd:
+                                    exec_cmd += " -c 4"
+                                if re.search(r"\bapt(-get)?\s+(install|upgrade|remove)\b", exec_cmd) and "-y" not in exec_cmd:
+                                    exec_cmd += " -y"
+
+                                # Instant frame-0 animated spinner with live visibility and timeout protection
                                 try:
-                                    with _Spin(f"executing: {disp_cmd}", min_seconds=0.1):
-                                        r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+                                    with _Spin(f"exec: {disp_cmd}", min_seconds=0.25, prefix=ts_pfx):
+                                        r = subprocess.run(
+                                            exec_cmd,
+                                            shell=True,
+                                            capture_output=True,
+                                            text=True,
+                                            timeout=60,
+                                            stdin=subprocess.DEVNULL,
+                                            errors="replace"
+                                        )
                                         elapsed_ms = (time.monotonic() - t0) * 1000
-                                        raw_out = r.stdout + r.stderr
+                                        raw_out = (r.stdout or "") + (r.stderr or "")
                                         returncode = r.returncode
                                 except subprocess.TimeoutExpired:
                                     elapsed_ms = 60000.0
                                     raw_out = "⛔ Command timed out after 60 seconds."
                                     returncode = 124
+                                except Exception as cmd_err:
+                                    elapsed_ms = (time.monotonic() - t0) * 1000
+                                    raw_out = f"⛔ Command execution error: {cmd_err}"
+                                    returncode = 1
 
                                 bounded_out = _smart_truncate_output(raw_out)
 
                                 ec_color = _G if returncode == 0 else _R
                                 ec_icon = f"{_G}✓{_RS}" if returncode == 0 else f"{_R}✗{_RS}"
-                                print(f"  {_GR}{now_str}{_RS}  {ec_icon} {ec_color}exec:{_RS} {disp_cmd} {ec_color}[{returncode}]{_RS} {_dim(f'{elapsed_ms:.1f}ms')}")
+                                print(f"{ts_pfx}  {ec_icon} {ec_color}exec:{_RS} {disp_cmd} {ec_color}[{returncode}]{_RS} {_dim(f'{elapsed_ms:.1f}ms')}")
 
                                 ws.send(json.dumps({
                                     "type": "tool_response",
@@ -3461,10 +3500,10 @@ def mcp_serve(
                                     "result": {"content": [{"type": "text", "text": bounded_out or "(no output)"}], "isError": returncode != 0}
                                 }))
                         elif t_name == "akash_undo":
-                            with _Spin("undo: reverting workspace to checkpoint", min_seconds=0.15):
+                            with _Spin("undo: reverting workspace to checkpoint", min_seconds=0.25, prefix=ts_pfx):
                                 ok, msg_txt = _restore_undo_checkpoint()
                             icon = f"{_G}✓{_RS}" if ok else f"{_R}✗{_RS}"
-                            print(f"  {_GR}{now_str}{_RS}  {icon} {(_G if ok else _R)}undo:{_RS} {_dim(msg_txt)}")
+                            print(f"{ts_pfx}  {icon} {(_G if ok else _R)}undo:{_RS} {_dim(msg_txt)}")
                             ws.send(json.dumps({
                                 "type": "tool_response",
                                 "id": call_id,
@@ -3474,10 +3513,10 @@ def mcp_serve(
                         elif t_name == "akash_checkpoint_create":
                             label = args.get("label", "agent_checkpoint")
                             from .terminal import build_snapshot
-                            with _Spin(f"checkpoint: {label} (packing workspace)", min_seconds=0.15):
+                            with _Spin(f"checkpoint: {label} (packing workspace)", min_seconds=0.25, prefix=ts_pfx):
                                 _, manifest, _ = build_snapshot(label=label)
                                 elapsed_ms = (time.monotonic() - t0) * 1000
-                            print(f"  {_GR}{now_str}{_RS}  {_C}📸 checkpoint:{_RS} {_dim(label)} ({len(manifest.get('files', []))} files) {_dim(f'{elapsed_ms:.1f}ms')}")
+                            print(f"{ts_pfx}  {_C}📸 checkpoint:{_RS} {_dim(label)} ({len(manifest.get('files', []))} files) {_dim(f'{elapsed_ms:.1f}ms')}")
                             ws.send(json.dumps({
                                 "type": "tool_response",
                                 "id": call_id,

{akashcli-4.7.5 → akashcli-4.7.7}/akashcli.egg-info/PKG-INFO

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

{akashcli-4.7.5 → akashcli-4.7.7}/pyproject.toml

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