kiwi-code 0.0.441__tar.gz → 0.0.443__tar.gz

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.441
+Version: 0.0.443
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.441"
+version = "0.0.443"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/src/kiwi_cli/__init__.py

@@ -1,3 +1,3 @@
 """Kiwi CLI - command-line interface and shared infrastructure modules."""
 
-__version__ = "0.0.441"
+__version__ = "0.0.443"

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/src/kiwi_runtime/__init__.py

@@ -1,3 +1,3 @@
 """Kiwi Runtime — terminal agent that connects to the server via WebSocket."""
 
-__version__ = "0.0.441"
+__version__ = "0.0.443"

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/src/kiwi_runtime/main.py

@@ -12,6 +12,7 @@ Usage:
     kiwi connect --server dev --scope full
     kiwi connect --server dev --allow /path/to/extra/dir
 """
+from collections import deque
 from datetime import datetime
 import argparse
 import asyncio
@@ -24,6 +25,8 @@ import shlex
 import signal
 import subprocess
 import sys
+import random
+import time
 from pathlib import Path
 from typing import Any
 import shutil
@@ -3243,6 +3246,7 @@ async def run_command(
         if not ok:
             return {"stdout": "", "stderr": reason, "exit_code": 1}
 
+    proc: asyncio.subprocess.Process | None = None
     try:
         cwd = allowed_dirs[0] if allowed_dirs else None
         proc = await asyncio.create_subprocess_shell(
@@ -3258,10 +3262,33 @@ async def run_command(
         stderr = stderr_bytes.decode("utf-8", errors="replace")[:MAX_OUTPUT_BYTES]
         return {"stdout": stdout, "stderr": stderr, "exit_code": proc.returncode}
     except asyncio.TimeoutError:
-        proc.kill()
-        await proc.wait()
+        if proc and proc.returncode is None:
+            try:
+                proc.kill()
+            except ProcessLookupError:
+                pass
+            try:
+                await proc.wait()
+            except Exception:
+                pass
         return {"stdout": "", "stderr": f"Command timed out after {timeout}s", "exit_code": -1}
+    except asyncio.CancelledError:
+        if proc and proc.returncode is None:
+            try:
+                proc.kill()
+            except ProcessLookupError:
+                pass
+            try:
+                await proc.wait()
+            except Exception:
+                pass
+        raise
     except Exception as e:
+        if proc and proc.returncode is None:
+            try:
+                proc.kill()
+            except Exception:
+                pass
         return {"stdout": "", "stderr": str(e), "exit_code": -1}
 
 
@@ -4199,16 +4226,152 @@ async def connect(
     allowed_dirs: list[str] | None = None,
     agent_id: str | None = None,
     consumer_id: str | None = None,
+    *,
+    max_retries: int = 12,
+ ):
+    ws_endpoint = f"{ws_url}/v1/terminal/ws/connect"
+    retries = 0
+
+    # Shared state across reconnect attempts.
+    pending_results: deque[dict[str, Any]] = deque()
+    pending_lock = asyncio.Lock()
+    pending_event = asyncio.Event()
+
+    command_queue: asyncio.Queue[tuple[str, str]] = asyncio.Queue(maxsize=64)
+    cmd_state: dict[str, Any] = {"running": False, "command": None}
+
+    async def _command_worker() -> None:
+        while True:
+            request_id, command = await command_queue.get()
+            result_msg: dict[str, Any] | None = None
+            cmd_state["running"] = True
+            cmd_state["command"] = command
+            try:
+                result = await run_command(
+                    command,
+                    mode=mode,
+                    allowed_dirs=allowed_dirs,
+                )
+                exit_code = 0
+                try:
+                    exit_code = int(result.get("exit_code", 0))
+                except Exception:
+                    exit_code = 0
+                success = exit_code == 0
+                status_msg = (
+                    f"{GREEN}OK{RESET}"
+                    if success
+                    else f"{RED}FAILED (exit {exit_code}){RESET}"
+                )
+                print_cmd_log(request_id, status_msg, success)
+                result_msg = {
+                    "type": "result",
+                    "request_id": request_id,
+                    **result,
+                }
+            except asyncio.CancelledError:
+                # Cancellation = runtime is shutting down. Let it propagate after cleanup.
+                raise
+            except Exception as e:
+                print_cmd_log(request_id, f"{RED}FAILED{RESET}", False)
+                result_msg = {
+                    "type": "result",
+                    "request_id": request_id,
+                    "stdout": "",
+                    "stderr": str(e),
+                    "exit_code": -1,
+                }
+            finally:
+                cmd_state["running"] = False
+                cmd_state["command"] = None
+                try:
+                    command_queue.task_done()
+                except Exception:
+                    pass
+            if result_msg is not None:
+                async with pending_lock:
+                    pending_results.append(result_msg)
+                pending_event.set()
+
+    command_worker_task = asyncio.create_task(_command_worker())
+    try:
+        while True:
+            attempt = retries + 1
+            total_attempts = max_retries + 1
+            print_status(
+                "~",
+                f"Connecting to {BOLD}{ws_endpoint}{RESET} {GREY}(attempt {attempt}/{total_attempts}){RESET}",
+                C,
+            )
+            try:
+                await _connect_once(
+                    ws_url,
+                    token,
+                    http_base_url=http_base_url,
+                    mode=mode,
+                    allowed_dirs=allowed_dirs,
+                    agent_id=agent_id,
+                    consumer_id=consumer_id,
+                    command_queue=command_queue,
+                    pending_results=pending_results,
+                    pending_lock=pending_lock,
+                    pending_event=pending_event,
+                    cmd_state=cmd_state,
+                )
+                return
+            except asyncio.CancelledError:
+                raise
+            except websockets.exceptions.ConnectionClosed as e:
+                print()
+                print_status("!", f"Connection closed: {e}", YELLOW)
+            except ConnectionRefusedError:
+                print()
+                print_status("x", f"Could not connect to {ws_endpoint}. Is the server running?", RED)
+            except Exception as e:
+                print()
+                print_status("x", f"Error: {e}", RED)
+
+            if retries >= max_retries:
+                print_status("x", f"Max reconnect attempts reached ({max_retries}).", RED)
+                return
+
+            retries += 1
+            base_delay = min(30.0, 1.5 * (2 ** (retries - 1)))
+            delay = base_delay + random.uniform(0.0, 0.6)
+            print_status(
+                "~",
+                f"Reconnecting in {delay:.1f}s... {GREY}(retry {retries}/{max_retries}){RESET}",
+                YELLOW,
+            )
+            await asyncio.sleep(delay)
+    finally:
+        if command_worker_task and not command_worker_task.done():
+            command_worker_task.cancel()
+            await asyncio.gather(command_worker_task, return_exceptions=True)
+
+
+async def _connect_once(
+    ws_url: str,
+    token: str,
+    http_base_url: str,
+    mode: str = "restricted",
+    allowed_dirs: list[str] | None = None,
+    agent_id: str | None = None,
+    consumer_id: str | None = None,
+    *,
+    command_queue: asyncio.Queue[tuple[str, str]],
+    pending_results: deque[dict[str, Any]],
+    pending_lock: asyncio.Lock,
+    pending_event: asyncio.Event,
+    cmd_state: dict[str, Any],
 ):
-    """Connect to the server WebSocket and process commands."""
     ws_endpoint = f"{ws_url}/v1/terminal/ws/connect"
-    print_status("~", f"Connecting to {BOLD}{ws_endpoint}{RESET}", C)
     background_tasks: set[asyncio.Task] = set()
     try:
         async with websockets.connect(
             ws_endpoint,
             ping_interval=20,
-            ping_timeout=60,
+            ping_timeout=90,
             close_timeout=10,
             max_queue=64,
         ) as ws:
@@ -4262,34 +4425,114 @@ async def connect(
             chunked_writes: dict[str, ChunkedWriteState] = {}
             paired_msg_count = 0
             fs_message_types = { "read_file","write_file","append_file","replace_in_file","stat_file","list_dir","mkdir","move_path","copy_path", "delete_path","apply_unified_diff","replace_line_range","insert_at_line","search_in_file","search_in_files","batch","file_write_start","file_write_chunk","file_write_finish","file_write_abort"}
+
+            hb_debug_env = os.environ.get("KIWI_RUNTIME_DEBUG_HEARTBEAT", "").strip().lower()
+            hb_debug = hb_debug_env not in ("", "0", "false", "no")
+            hb_log_every_s = 5.0
+            try:
+                hb_log_every_s = float(os.environ.get("KIWI_RUNTIME_DEBUG_HEARTBEAT_INTERVAL", "5") or "5")
+            except Exception:
+                hb_log_every_s = 5.0
+
+            hb_ws_ping_env = os.environ.get("KIWI_RUNTIME_DEBUG_HEARTBEAT_WS_PING", "").strip().lower()
+            hb_ws_ping = hb_ws_ping_env not in ("", "0", "false", "no")
+            hb_ws_ping_timeout_s = 5.0
+            try:
+                hb_ws_ping_timeout_s = float(os.environ.get("KIWI_RUNTIME_DEBUG_HEARTBEAT_WS_PING_TIMEOUT", "5") or "5")
+            except Exception:
+                hb_ws_ping_timeout_s = 5.0
+
+            heartbeat_debug_task: asyncio.Task | None = None
+            pending_sender_task: asyncio.Task | None = None
+
+            async def _pending_sender_loop() -> None:
+                while True:
+                    item: dict[str, Any] | None = None
+                    async with pending_lock:
+                        if pending_results:
+                            item = pending_results.popleft()
+
+                    if item is None:
+                        pending_event.clear()
+                        async with pending_lock:
+                            if pending_results:
+                                continue
+                        await pending_event.wait()
+                        continue
+                    try:
+                        await ws.send(json.dumps(item))
+                    except asyncio.CancelledError:
+                        raise
+                    except Exception:
+                        async with pending_lock:
+                            pending_results.appendleft(item)
+                        pending_event.set()
+                        raise
+
+            pending_sender_task = asyncio.create_task(_pending_sender_loop())
+
+            async def _heartbeat_debug_loop() -> None:
+                while True:
+                    await asyncio.sleep(max(0.2, hb_log_every_s))
+                    if not bool(cmd_state.get("running")):
+                        continue
+                    qsize = 0
+                    try:
+                        qsize = command_queue.qsize()
+                    except Exception:
+                        qsize = 0
+                    msg = f"Heartbeat(debug) | busy=True queue={qsize}"
+                    cmd = cmd_state.get("command")
+                    if cmd:
+                        cleaned = str(cmd).strip().replace("\n", " ")
+                        if len(cleaned) > 60:
+                            cleaned = cleaned[:57] + "..."
+                        msg += f" | cmd={cleaned}"
+                    if hb_ws_ping:
+                        try:
+                            waiter = await ws.ping()
+                            await asyncio.wait_for(waiter, timeout=hb_ws_ping_timeout_s)
+                            msg += " | ws_pong=ok"
+                        except Exception:
+                            msg += " | ws_pong=fail"
+                    print_status("·", msg, GREY)
+
+            if hb_debug:
+                heartbeat_debug_task = asyncio.create_task(_heartbeat_debug_loop())
+
             try:
                 async for message in ws:
                     msg = json.loads(message)
                     msg_type = msg.get("type")
 
+                    if pending_sender_task and pending_sender_task.done():
+                        try:
+                            exc = pending_sender_task.exception()
+                        except asyncio.CancelledError:
+                            exc = None
+                        if exc:
+                            raise exc
+                        raise RuntimeError("Pending sender exited unexpectedly")
+
+
                     if msg_type == "command":
                         request_id = msg.get("request_id", "")
                         command = msg.get("command", "")
                         print_cmd_log(request_id, f"$ {BOLD}{command}{RESET}")
 
-                        result = await run_command(
-                            command,
-                            mode=mode,
-                            allowed_dirs=allowed_dirs,
-                        )
-                        exit_code = result["exit_code"]
-                        success = exit_code == 0
-                        status_text = (
-                            f"{GREEN}OK{RESET}" if success
-                            else f"{RED}FAILED (exit {exit_code}){RESET}"
-                        )
-                        print_cmd_log(request_id, status_text, success)
+                        try:
+                            command_queue.put_nowait((str(request_id), str(command)))
+                        except asyncio.QueueFull:
+                            err = "Runtime command queue full; please retry."
+                            print_cmd_log(request_id, f"{RED}FAILED{RESET}", False)
+                            await ws.send(json.dumps({
+                                "type": "result",
+                                "request_id": request_id,
+                                "stdout": "",
+                                "stderr": err,
+                                "exit_code": 1,
+                            }))
 
-                        await ws.send(json.dumps({
-                            "type": "result",
-                            "request_id": request_id,
-                            **result,
-                        }))
 
                     elif msg_type == "interactive":
                         request_id = msg.get("request_id", "")
@@ -4304,7 +4547,12 @@ async def connect(
                         )
                         exit_code = result["exit_code"]
                         success = exit_code == 0
-                        print_cmd_log(request_id, f"{'OK' if success else f'FAILED (exit {exit_code})'}", success)
+                        status_msg = (
+                            f"{GREEN}OK{RESET}"
+                            if success
+                            else f"{RED}FAILED (exit {exit_code}){RESET}"
+                        )
+                        print_cmd_log(request_id, status_msg, success)
 
                         await ws.send(json.dumps({
                             "type": "result",
@@ -4557,9 +4805,17 @@ async def connect(
                     elif msg_type == "ping":
                         await ws.send(json.dumps({"type": "pong"}))
 
+
                     else:
                         print_status("?", f"Unknown message: {msg_type}", YELLOW)
             finally:
+                if heartbeat_debug_task and not heartbeat_debug_task.done():
+                    heartbeat_debug_task.cancel()
+                    await asyncio.gather(heartbeat_debug_task, return_exceptions=True)
+
+                if pending_sender_task and not pending_sender_task.done():
+                    pending_sender_task.cancel()
+                    await asyncio.gather(pending_sender_task, return_exceptions=True)
                 bg_tasks = list(background_tasks)
                 for task in bg_tasks:
                     task.cancel()
@@ -4584,15 +4840,10 @@ async def connect(
                     except Exception:
                         pass
 
-    except websockets.exceptions.ConnectionClosed as e:
-        print()
-        print_status("!", f"Connection closed: {e}", YELLOW)
-    except ConnectionRefusedError:
-        print()
-        print_status("x", f"Could not connect to {ws_endpoint}. Is the server running?", RED)
-    except Exception as e:
-        print()
-        print_status("x", f"Error: {e}", RED)
+    except asyncio.CancelledError:
+        raise
+    except Exception:
+        raise
 
 
 def main():

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/src/kiwi_tui/__init__.py

@@ -1,3 +1,3 @@
 """Autobots TUI - A textual-based terminal user interface."""
 
-__version__ = "0.0.441"
+__version__ = "0.0.443"

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/src/kiwi_tui/main.py

@@ -929,43 +929,6 @@ class AutobotsTUI(App):
     def action_quit(self) -> None:
         """Quit the application."""
         self.request_quit()
-        try:
-            all_rt = list_known_runtimes()
-        except Exception:
-            all_rt = []
-
-        alive = [r for r in all_rt if r.get("alive") and r.get("pid")]
-        if not alive:
-            self._final_exit()
-            return
-
-        rows: list[RuntimeRow] = []
-        for r in alive:
-            try:
-                meta = r.get("meta") or {}
-                name = None
-                if isinstance(meta, dict):
-                    name = meta.get("run_name")
-                rows.append(
-                    RuntimeRow(
-                        kind=str(r.get("kind")),
-                        runtime_id=str(r.get("id")),
-                        pid=int(r.get("pid")),
-                        alive=True,
-                        log_path=str(r.get("log_path")),
-                        name=name if isinstance(name, str) else None,
-                        kill=False,
-                    )
-                )
-            except Exception:
-                continue
-
-        # Show interactive prompt; the callback will exit.
-        self.push_screen(RuntimeCleanupScreen(rows), callback=self._on_runtime_cleanup_done)
-
-    def action_quit(self) -> None:
-        """Quit the application."""
-        self.request_quit()
 
 
 def _run_tui(runtime_args: RuntimeConnectArgs | None = None):

{kiwi_code-0.0.441 → kiwi_code-0.0.443}/src/kiwi_tui/runtime_agent.py

@@ -242,14 +242,11 @@ def _pid_matches_create_time(pid: int, expected_create_time: float | None) -> bo
 
 
 def _runtime_valid(pid: int, *, meta: dict[str, Any] | None, log_path: Path) -> bool:
-    """Determine whether an on-disk runtime record is still usable."""
     if not pid:
         return False
     if not _pid_alive(pid):
         return False
-    if not _pid_is_kiwi_runtime(pid):
-        return False
-    expected_ct = None
+    expected_ct: float | None = None
     try:
         if isinstance(meta, dict):
             expected_ct = meta.get("create_time")
@@ -259,10 +256,21 @@ def _runtime_valid(pid: int, *, meta: dict[str, Any] | None, log_path: Path) ->
         expected_ct = None
     if not _pid_matches_create_time(pid, expected_ct if isinstance(expected_ct, (int, float)) else None):
         return False
-    # If logs show a disconnect, treat the runtime as invalid so it can be restarted.
+    
     if _log_indicates_disconnected(log_path):
         return False
-    return True
+    
+    if _pid_is_kiwi_runtime(pid):
+        return True
+
+    if expected_ct is not None and isinstance(meta, dict) and meta.get("tui_managed"):
+        try:
+            exe = psutil.Process(pid).exe().lower()
+            if "python" in exe:
+                return True
+        except Exception:
+            pass
+    return False
 
 
 def _pid_alive(pid: int) -> bool:
@@ -826,6 +834,14 @@ def list_known_runtimes() -> list[dict[str, Any]]:
                 except Exception:
                     meta = {}
 
+            if pid is None and isinstance(meta, dict):
+                try:
+                    mpid = meta.get("pid")
+                    if isinstance(mpid, (int, float, str)) and str(mpid).strip():
+                        pid = int(mpid)
+                except Exception:
+                    pid = None
+
             # If a pending runtime was soft-bound to a run, skip it to avoid duplicate
             # entries in cleanup screens.
             if kind == "pending" and meta.get("bound_run_id"):