kiwi-code 0.0.25__tar.gz → 0.0.26__tar.gz

{kiwi_code-0.0.25 → kiwi_code-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.25
+Version: 0.0.26
 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.25 → kiwi_code-0.0.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.25"
+version = "0.0.26"
 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.25 → kiwi_code-0.0.26}/src/kiwi_tui/runtime_agent.py

@@ -27,6 +27,8 @@ import json
 import os
 from pathlib import Path
 import subprocess
+import threading
+import time
 from typing import Any, Literal
 import uuid
 
@@ -57,6 +59,111 @@ BY_RUN_DIR = RUNTIMES_DIR / "by-run"
 PENDING_DIR = RUNTIMES_DIR / "pending"
 
 
+# Runtime log truncation
+# ---------------------
+# Runtime logs are written to a local file and can otherwise grow without bound,
+# consuming both disk and memory (the logs viewer historically read the entire
+# file into RAM). We keep only a small trailing window so the user sees the most
+# recent activity.
+MAX_RUNTIME_LOG_BYTES = 30 * 1024
+_RUNTIME_LOG_TRIM_INTERVAL_SEC = 0.5
+
+
+def _trim_file_to_tail_bytes(path: Path, *, max_bytes: int = MAX_RUNTIME_LOG_BYTES) -> None:
+    """Trim a file in-place to keep only the last ``max_bytes`` bytes.
+
+    Notes:
+    - We *cannot* implement trimming via atomic replace (write temp + rename),
+      because the runtime process inherits an open file descriptor; replacing the
+      path would orphan the original inode and the runtime would keep writing to
+      the unlinked file.
+    - This is therefore best-effort; concurrent appends may result in dropping a
+      few bytes around the trim boundary, which is acceptable for log viewing.
+    """
+    if max_bytes <= 0:
+        return
+    try:
+        if not path.exists():
+            return
+        with open(path, "r+b") as fp:
+            fp.seek(0, os.SEEK_END)
+            size = fp.tell()
+            if size <= max_bytes:
+                return
+
+            # Read the tail and try to start at a newline boundary to avoid
+            # rendering a partial first line.
+            fp.seek(max(0, size - max_bytes), os.SEEK_SET)
+            tail = fp.read(max_bytes)
+            if size > max_bytes:
+                nl = tail.find(b"\n")
+                if 0 <= nl < len(tail) - 1:
+                    tail = tail[nl + 1 :]
+
+            fp.seek(0, os.SEEK_SET)
+            fp.write(tail)
+            fp.truncate(len(tail))
+            try:
+                fp.flush()
+            except Exception:
+                pass
+    except Exception:
+        # Never crash UI / runtime manager due to log trimming.
+        return
+
+
+class _RuntimeLogTrimmer(threading.Thread):
+    def __init__(self, *, log_path: Path, pid: int | None, max_bytes: int) -> None:
+        super().__init__(daemon=True)
+        self._log_path = log_path
+        self._pid = pid
+        self._max_bytes = max_bytes
+        self._stop = threading.Event()
+        self._missing_count = 0
+
+    def stop(self) -> None:
+        self._stop.set()
+
+    def run(self) -> None:
+        while not self._stop.is_set():
+            try:
+                if self._pid and not psutil.pid_exists(self._pid):
+                    break
+            except Exception:
+                # If we can't check, keep trimming while the app is alive.
+                pass
+
+            if not self._log_path.exists():
+                self._missing_count += 1
+                # If the log path was moved (e.g. pending -> by-run), another
+                # trimmer should be started for the new path.
+                if self._missing_count > 20:
+                    break
+            else:
+                self._missing_count = 0
+                _trim_file_to_tail_bytes(self._log_path, max_bytes=self._max_bytes)
+
+            self._stop.wait(_RUNTIME_LOG_TRIM_INTERVAL_SEC)
+
+        # One final trim on exit.
+        _trim_file_to_tail_bytes(self._log_path, max_bytes=self._max_bytes)
+
+
+_LOG_TRIMMERS: dict[str, _RuntimeLogTrimmer] = {}
+_LOG_TRIMMERS_LOCK = threading.Lock()
+
+
+def _ensure_log_trimmer(*, log_path: Path, pid: int | None, max_bytes: int = MAX_RUNTIME_LOG_BYTES) -> None:
+    key = str(log_path)
+    with _LOG_TRIMMERS_LOCK:
+        trimmer = _LOG_TRIMMERS.get(key)
+        if trimmer and trimmer.is_alive():
+            return
+        trimmer = _RuntimeLogTrimmer(log_path=log_path, pid=pid, max_bytes=max_bytes)
+        _LOG_TRIMMERS[key] = trimmer
+        trimmer.start()
+
+
 
 def _read_pid(path: Path) -> int | None:
     if not path.exists():
@@ -350,6 +457,9 @@ def _spawn_runtime(
             pass
         return False, None, f"Failed to start runtime: {e}"
 
+
+    # Keep runtime log file bounded in the background (avoid disk + RAM blow-ups).
+    _ensure_log_trimmer(log_path=log_path, pid=proc.pid)
     try:
         pid_path.write_text(str(proc.pid), encoding="utf-8")
     except Exception:
@@ -385,6 +495,7 @@ def ensure_runtime_for_run(
     existing = get_running_pid_for_run(run_id)
     lp = log_path_for_run(run_id)
     if existing:
+        _ensure_log_trimmer(log_path=lp, pid=existing)
         return True, existing, lp, f"Runtime already running for run {run_id} (pid={existing})"
 
     ok, pid, msg = _spawn_runtime(
@@ -530,6 +641,14 @@ def bind_pending_to_run(
     except Exception:
         pass
 
+
+    # If the pending runtime directory was moved successfully, start trimming at the
+    # new by-run log path (the old path no longer exists).
+    try:
+        pid = _read_pid(dst / "pid")
+        _ensure_log_trimmer(log_path=dst / "log", pid=pid)
+    except Exception:
+        pass
     return True, dst / "log", f"Bound pending runtime {pending_id} -> run {run_id}"
 
 

{kiwi_code-0.0.25 → kiwi_code-0.0.26}/src/kiwi_tui/screens/runtime_logs.py

@@ -17,12 +17,30 @@ from textual.screen import Screen
 from textual.widgets import Footer, Header, RichLog, Static
 
 
-def _tail_lines(path: Path, max_lines: int = 3000) -> list[str]:
-    """Read the last N lines of a file without loading the whole file."""
+def _tail_lines(path: Path, max_lines: int = 3000, max_bytes: int = 30 * 1024) -> list[str]:
+    """Read the last N lines of a file without loading the whole file.
+
+    We read only a tail window (``max_bytes``) so opening the logs screen doesn't
+    allocate RAM proportional to the on-disk log size.
+    """
+    if max_bytes <= 0:
+        return []
+
     try:
-        data = path.read_bytes()
+        with open(path, "rb") as fp:
+            fp.seek(0, 2)
+            size = fp.tell()
+            fp.seek(max(0, size - max_bytes), 0)
+            data = fp.read(max_bytes)
     except OSError:
         return []
+
+    # If we started mid-file, drop the partial first line.
+    if size > max_bytes:
+        nl = data.find(b"\n")
+        if 0 <= nl < len(data) - 1:
+            data = data[nl + 1 :]
+
     lines = data.splitlines()[-max_lines:]
     out: list[str] = []
     for b in lines:
@@ -120,6 +138,15 @@ class RuntimeLogsScreen(Screen):
         except Exception:
             return
         if not chunk:
+            # If the runtime log is being trimmed in-place, the file can shrink.
+            # When that happens our read cursor may point past EOF; re-seek to the
+            # new end so streaming continues.
+            try:
+                if self._log_path and self._log_path.exists():
+                    if self._log_path.stat().st_size < self._fp.tell():
+                        self._fp.seek(0, 2)
+            except Exception:
+                pass
             return
 
         try:

kiwi_code-0.0.26/tests/test_runtime_log_trimming.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from kiwi_tui.runtime_agent import MAX_RUNTIME_LOG_BYTES, _trim_file_to_tail_bytes
+from kiwi_tui.screens.runtime_logs import _tail_lines
+
+
+def _make_log_bytes(num_lines: int) -> bytes:
+    # Fixed-width lines make expected tails deterministic.
+    return b"".join([f"line-{i:06d} hello world\n".encode("utf-8") for i in range(num_lines)])
+
+
+def test_trim_file_to_tail_bytes_keeps_last_bytes(tmp_path: Path) -> None:
+    p = tmp_path / "log"
+    payload = _make_log_bytes(20000)  # plenty bigger than 30KB
+    p.write_bytes(payload)
+
+    _trim_file_to_tail_bytes(p, max_bytes=MAX_RUNTIME_LOG_BYTES)
+
+    data = p.read_bytes()
+    assert len(data) <= MAX_RUNTIME_LOG_BYTES
+
+    # We should keep the most recent line.
+    assert b"line-019999" in data
+
+    # We should *not* keep the earliest line.
+    assert b"line-000000" not in data
+
+
+def test_tail_lines_reads_tail_window(tmp_path: Path) -> None:
+    p = tmp_path / "log"
+    payload = _make_log_bytes(5000)
+    p.write_bytes(payload)
+
+    # Read a small tail window and last few lines from it.
+    lines = _tail_lines(p, max_lines=5, max_bytes=512)
+    assert len(lines) == 5
+
+    # Must include the final log line.
+    assert lines[-1].startswith("line-004999")

{kiwi_code-0.0.25 → kiwi_code-0.0.26}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.25"
+version = "0.0.26"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },