kiwi-code 0.0.506__tar.gz → 0.0.507__tar.gz

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.506
+Version: 0.0.507
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.506"
+version = "0.0.507"
 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.506 → kiwi_code-0.0.507}/src/kiwi_cli/edition.py

@@ -27,6 +27,10 @@ EDITIONS: dict[str, dict[str, str]] = {
     },
 }
 
+#: The package this build was published as: kiwi-ai or kiwi-code (see the module's
+#: docstring). Unlike EDITION, KIWI_EDITION does not change it: it names what is
+#: installed, which is what an update must ask PyPI for and install.
+BUILD_EDITION = _BUILD_EDITION
 EDITION = os.environ.get("KIWI_EDITION") or _BUILD_EDITION
 if EDITION not in EDITIONS:
     raise ValueError(f"Unknown KIWI_EDITION {EDITION!r}; expected one of {sorted(EDITIONS)}")
@@ -38,10 +42,10 @@ DEFAULT_ACCOUNT = EDITIONS[EDITION]["default_account"]
 
 
 def _installed_version() -> str:
-    # Ask whichever distribution ships kiwi_cli (kiwi-ai or kiwi-code), so the
-    # version is right regardless of KIWI_EDITION. Editable installs don't map
-    # kiwi_cli to a distribution, so also try each edition's package name.
-    for dist in [*metadata.packages_distributions().get("kiwi_cli", []), *EDITIONS]:
+    # The package this build was published as comes first: when kiwi-ai and kiwi-code
+    # are both installed in one environment, both ship kiwi_cli. Then whichever
+    # distribution ships kiwi_cli, and each edition's name (a local checkout).
+    for dist in [BUILD_EDITION, *metadata.packages_distributions().get("kiwi_cli", []), *EDITIONS]:
         try:
             return metadata.version(dist)
         except metadata.PackageNotFoundError:

kiwi_code-0.0.507/src/kiwi_tui/autoupdate.py

@@ -0,0 +1,216 @@
+"""Keeping kiwi up to date on its own.
+
+While kiwi runs, the dashboard asks PyPI for the latest release (see
+`TermDashboardScreen._check_latest_version`) and remembers it here, in
+`~/.kiwi/update.json`. At the next start, before the TUI opens, a newer release is
+installed with the tool kiwi was installed with, and the new version is started instead.
+Installing at start rather than under a running session matters: kiwi imports parts of
+itself as they are needed, and those must not come from another version.
+
+Never updated on its own: an editable or local checkout, kiwi outside a virtual
+environment (a system Python is the user's to manage), Windows (the running `kiwi.exe`
+cannot be replaced), a start that is not interactive, or when turned off with
+`/autoupdate off` or `KIWI_NO_AUTO_UPDATE=1`. Those get the command to run instead.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from importlib import metadata
+from pathlib import Path
+
+#: How long an update may take before kiwi gives up and starts the version it has.
+INSTALL_TIMEOUT = 180
+#: A release that would not install is tried again after this long.
+RETRY_AFTER = 24 * 3600
+#: Set in the new version's environment, so it can say what it was updated from (and so a
+#: failed update cannot loop).
+UPDATED_FROM_ENV = "KIWI_UPDATED_FROM"
+
+
+@dataclass(frozen=True)
+class Installer:
+    name: str  # uv / pipx / pip
+    command: tuple[str, ...]  # what updates kiwi
+    manual: str  # the same, for the user to type
+
+
+def package_name() -> str:
+    """The PyPI package kiwi was installed as: kiwi-ai or kiwi-code. Both are built from
+    this one codebase; the build bakes in which one it is (scripts/set_edition.py), and
+    KIWI_EDITION, which only points kiwi at the other backend, does not change it."""
+    from kiwi_cli.edition import BUILD_EDITION
+
+    return BUILD_EDITION
+
+
+def _state_path() -> Path:
+    from kiwi_cli.checkpoints import kiwi_home_dir
+
+    return kiwi_home_dir() / "update.json"
+
+
+def _read_all() -> dict:
+    try:
+        data = json.loads(_state_path().read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _read_state() -> dict:
+    """This package's part: kiwi-ai and kiwi-code share ~/.kiwi, each with its own
+    releases and versions."""
+    state = _read_all().get(package_name())
+    return state if isinstance(state, dict) else {}
+
+
+def _write_state(**patch) -> None:
+    try:
+        path = _state_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        everything = _read_all()
+        everything[package_name()] = {**_read_state(), **patch}
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(everything), encoding="utf-8")
+        os.replace(tmp, path)
+    except OSError:
+        pass
+
+
+def record_latest(version: str) -> None:
+    """The latest release PyPI has, for the next start to install."""
+    _write_state(latest=str(version), checked_at=time.time())
+
+
+def newer(latest: str, current: str) -> bool:
+    try:
+        from packaging.version import Version
+
+        return Version(latest) > Version(current)
+    except Exception:
+        return False
+
+
+def pending(current: str, *, now: float | None = None) -> str | None:
+    """A newer release found earlier and not given up on: the version to install."""
+    state = _read_state()
+    latest = str(state.get("latest") or "")
+    if not latest or not newer(latest, current):
+        return None
+    now = time.time() if now is None else now
+    if state.get("failed") == latest and now - float(state.get("failed_at") or 0) < RETRY_AFTER:
+        return None
+    return latest
+
+
+def enabled(env=os.environ) -> bool:
+    if env.get("KIWI_NO_AUTO_UPDATE", "").strip().lower() in ("1", "true", "yes"):
+        return False
+    try:
+        from kiwi_tui.ui_settings import load_settings
+
+        return load_settings().get("auto_update", True) is not False
+    except Exception:
+        return True
+
+
+def _editable(package: str) -> bool:
+    """A checkout installed in place (`pip install -e`, `uv run`): never updated from PyPI."""
+    try:
+        raw = metadata.distribution(package).read_text("direct_url.json")
+    except Exception:
+        return False
+    if not raw:
+        return False
+    try:
+        info = json.loads(raw)
+    except ValueError:
+        return False
+    return bool(info.get("dir_info", {}).get("editable")) or str(info.get("url", "")).startswith("file:")
+
+
+def installer(package: str, *, prefix: str | None = None, base_prefix: str | None = None,
+              platform: str | None = None) -> Installer | None:
+    """How kiwi was installed, and so how to update it; None when kiwi must not update
+    itself (see the module's docstring)."""
+    prefix = sys.prefix if prefix is None else prefix
+    base_prefix = sys.base_prefix if base_prefix is None else base_prefix
+    platform = platform or sys.platform
+    if platform == "win32" or prefix == base_prefix or _editable(package):
+        return None
+    # Each tool leaves a file of its own in the environments it makes; the path is the
+    # fallback (a tool folder can be moved with UV_TOOL_DIR / PIPX_HOME).
+    env, parts = Path(prefix), Path(prefix).parts
+    if (env / "uv-receipt.toml").exists() or ("uv" in parts and "tools" in parts):
+        return Installer("uv", ("uv", "tool", "upgrade", package), f"uv tool upgrade {package}")
+    if (env / "pipx_metadata.json").exists() or ("pipx" in parts and "venvs" in parts):
+        return Installer("pipx", ("pipx", "upgrade", package), f"pipx upgrade {package}")
+    return Installer(
+        "pip", (sys.executable, "-m", "pip", "install", "--upgrade", "--quiet", package),
+        f"pip install --upgrade {package}",
+    )
+
+
+def manual_command(package: str) -> str:
+    """What the user should type to update, for the notice when kiwi will not do it."""
+    found = None
+    try:
+        found = installer(package, platform="linux")  # the right tool even on Windows
+    except Exception:
+        pass
+    return found.manual if found else f"pip install --upgrade {package}"
+
+
+def _version_on_disk(package: str) -> str | None:
+    """The installed version as a new process sees it (this one has the old one cached)."""
+    try:
+        out = subprocess.run(
+            [sys.executable, "-c", f"import importlib.metadata as m; print(m.version({package!r}))"],
+            capture_output=True, text=True, timeout=30,
+        )
+        return out.stdout.strip() or None
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def update_before_start(current: str, *, interactive: bool) -> bool:
+    """At start, before the TUI: install a newer release found earlier. Whether it was
+    installed (the caller then starts the new version)."""
+    if not interactive or os.environ.get(UPDATED_FROM_ENV) or not enabled():
+        return False
+    latest = pending(current)
+    if latest is None:
+        return False
+    package = package_name()
+    tool = installer(package)
+    if tool is None:
+        return False
+
+    print(f"Updating {package} v{current} → v{latest}…", flush=True)
+    try:
+        done = subprocess.run(
+            list(tool.command), stdin=subprocess.DEVNULL, capture_output=True, text=True,
+            timeout=INSTALL_TIMEOUT,
+        )
+        ok = done.returncode == 0
+        why = (done.stderr or done.stdout or "").strip().splitlines()[-1:] or [""]
+    except (OSError, subprocess.SubprocessError) as e:
+        ok, why = False, [str(e)]
+    if ok and not newer(_version_on_disk(package) or current, current):
+        ok, why = False, ["the new release did not install"]
+    if not ok:
+        _write_state(failed=latest, failed_at=time.time())
+        print(f"Could not update ({why[0]}). Starting v{current}; update with: {tool.manual}", flush=True)
+        return False
+    return True
+
+
+def restart_updated(current: str) -> None:
+    """Start the version just installed in place of this process."""
+    env = {**os.environ, UPDATED_FROM_ENV: current}
+    os.execve(sys.executable, [sys.executable, "-m", "kiwi_tui.main", *sys.argv[1:]], env)

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/src/kiwi_tui/main.py

@@ -1368,6 +1368,14 @@ def main() -> int:
             )
         )
 
+    # A newer release found by an earlier session is installed now, before the TUI opens,
+    # and started in place of this one.
+    from kiwi_tui import autoupdate
+
+    interactive = sys.stdin.isatty() and sys.stdout.isatty()
+    if autoupdate.update_before_start(KIWI_CODE_VERSION, interactive=interactive):
+        autoupdate.restart_updated(KIWI_CODE_VERSION)
+
     _run_term_tui(runtime_args=runtime_args)
     return 0
 

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/src/kiwi_tui/screens/term_dashboard.py

@@ -40,7 +40,6 @@ from kiwi_tui.screens.file_browser import FileBrowserScreen
 from kiwi_tui.screens.help import HelpScreen
 from kiwi_tui.screens.command_result import CommandResultScreen
 from kiwi_cli.autocode import AutocodeActions, fetch_autocode_actions, is_autocode_name
-from kiwi_cli.edition import EDITION
 from kiwi_tui import __version__ as KIWI_CODE_VERSION
 
 from common.banner import LOGO, TEXT
@@ -570,22 +569,36 @@ class TermDashboardScreen(Screen):
 
     # ── Dynamic tip ──────────────────────────────────────────
     async def _check_latest_version(self) -> None:
-        """Background check: compare installed version against PyPI latest."""
+        """Background check: compare installed version against PyPI latest. A newer one is
+        remembered, for the next start to install (kiwi_tui.autoupdate)."""
+        import os
+
         import httpx
-        from packaging.version import Version
+
+        from kiwi_tui import autoupdate
+
+        updated_from = os.environ.get(autoupdate.UPDATED_FROM_ENV)
+        if updated_from:
+            self._upgrade_tip = f"Updated: v{updated_from} → v{KIWI_CODE_VERSION}."
+            self._refresh_tip()
+        # The package installed (kiwi-ai or kiwi-code), not the backend kiwi was pointed
+        # at: they are released separately, each with its own versions.
+        package = autoupdate.package_name()
         try:
             async with httpx.AsyncClient(timeout=5) as client:
-                resp = await client.get(f"https://pypi.org/pypi/{EDITION}/json")
+                resp = await client.get(f"https://pypi.org/pypi/{package}/json")
             if resp.status_code != 200:
                 return
             latest = resp.json()["info"]["version"]
-            if Version(latest) > Version(KIWI_CODE_VERSION):
-                self._upgrade_tip = (
-                    f"A new version is available! "
-                    f"v{KIWI_CODE_VERSION} → v{latest}. "
-                    f"Run: pip install --upgrade {EDITION}"
-                )
-                self._refresh_tip()
+            if not autoupdate.newer(latest, KIWI_CODE_VERSION):
+                return
+            autoupdate.record_latest(latest)
+            if autoupdate.enabled() and autoupdate.installer(package) is not None:
+                how = "kiwi updates itself at the next start."
+            else:
+                how = f"Run: {autoupdate.manual_command(package)}"
+            self._upgrade_tip = f"A new version is available! v{KIWI_CODE_VERSION} → v{latest}. {how}"
+            self._refresh_tip()
         except Exception:
             pass
 
@@ -2750,8 +2763,9 @@ class TermDashboardScreen(Screen):
             _do()
 
     def _call_for_attention(self, kind: str, *, answer: object = "") -> None:
-        """The run waits for the user's answer, or is done: call them back if they are
-        away from kiwi (notification, bell, tab title; see kiwi_tui.attention)."""
+        """The run waits for the user's answer, is done, or has failed: call them back if
+        they are away from kiwi (notification, bell, tab title; see kiwi_tui.attention).
+        `answer` is the reply, or the error of a failed run."""
         if kind == "question":
             from kiwi_cli.human_questions import PENDING
 
@@ -2762,6 +2776,10 @@ class TermDashboardScreen(Screen):
             if len(pending) > 1:
                 body = f"{body} (+{len(pending) - 1} more)"
             title, tab = "Kiwi needs your answer", "● kiwi – waiting for you"
+        elif kind == "failed":
+            lines = str(answer or "").strip().splitlines()
+            body = lines[0].strip() if lines else "The run failed."
+            title, tab = "Kiwi run failed", "✗ kiwi – failed"
         else:
             lines = str(answer or "").strip().splitlines()
             body = lines[0].lstrip("#*> ").strip() if lines else "The run has finished."
@@ -3331,6 +3349,40 @@ class TermDashboardScreen(Screen):
                     self._show_inline_cmd_result(command, token_usage_renderable(usage, cyan=cyan))
                 return
 
+            if cmd == "/autoupdate":
+                import os
+
+                from kiwi_tui import autoupdate
+                from kiwi_tui.ui_settings import update_settings
+
+                choice = args[0].lower() if args else ""
+                if choice in ("on", "off"):
+                    update_settings({"auto_update": choice == "on"})
+                    toast("Auto-update on: a new release is installed when kiwi starts."
+                          if choice == "on" else "Auto-update off.", title="/autoupdate")
+                    return
+                package = autoupdate.package_name()
+                tool = autoupdate.installer(package)
+                if os.environ.get("KIWI_NO_AUTO_UPDATE"):
+                    state = "off (KIWI_NO_AUTO_UPDATE is set)"
+                elif not autoupdate.enabled():
+                    state = "off"
+                elif tool is None:
+                    state = "not possible for this install (a local checkout, a system Python or Windows)"
+                else:
+                    state = f"on (with {tool.name})"
+                show("\n".join([
+                    f"Auto-update: {state}",
+                    f"Installed: {package} v{KIWI_CODE_VERSION}",
+                    "",
+                    "A newer release found while kiwi runs is installed at the next start.",
+                    "",
+                    "  /autoupdate on    update at start (default)",
+                    "  /autoupdate off   never; kiwi only says a new version is out",
+                    f"  Update by hand:   {autoupdate.manual_command(package)}",
+                ]))
+                return
+
             if cmd == "/notify":
                 from kiwi_tui import attention
                 from kiwi_tui.ui_settings import load_settings, update_settings
@@ -5262,6 +5314,7 @@ class TermDashboardScreen(Screen):
                         got_final = True
                         self._set_run_inflight(False)
                         self._set_streaming(False)
+                        self._call_for_attention("failed", answer=err_msg)
                         return True
                     # `waiting`: the turn ended asking the user; finished until they answer.
                     if status not in ("completed", "success", "finished", WAITING_STATUS):

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/src/kiwi_tui/screens/term_dashboard_helpers.py

@@ -31,6 +31,7 @@ STREAMING_SAFE_SLASH_PREFIXES = (
     "/help",
     "/theme",
     "/notify",
+    "/autoupdate",
     "/show-logs",
     "/status",
     "/cancel",

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/src/kiwi_tui/slash_commands.py

@@ -56,6 +56,11 @@ SLASH_COMMANDS: list[SlashCommand] = [
     SlashCommand("Runtime", "/show-logs", "Show local CLI (runtime) logs", "/show-logs"),
     SlashCommand("Runtime", "/runtime", "Runtime commands (currently disabled)", "/runtime"),
 
+    # Updates
+    SlashCommand("Update", "/autoupdate", "Whether kiwi updates itself, and how", "/autoupdate"),
+    SlashCommand("Update", "/autoupdate on", "Install new releases when kiwi starts", "/autoupdate on"),
+    SlashCommand("Update", "/autoupdate off", "Never update on its own", "/autoupdate off"),
+
     # Notifications
     SlashCommand("Notify", "/notify", "How kiwi calls you back when it needs you", "/notify"),
     SlashCommand("Notify", "/notify on", "Notification and bell when a question waits or a run finishes", "/notify on"),

{kiwi_code-0.0.506 → kiwi_code-0.0.507}/tests/test_attention.py

@@ -126,10 +126,12 @@ async def test_a_waiting_question_names_itself_and_a_finished_run_its_answer(mon
 
         screen._call_for_attention("question")
         screen._call_for_attention("finished", answer="## Done\nAll tests pass.")
+        screen._call_for_attention("failed", answer="Tool call timed out\nTraceback …")
         assert calls == [
             {"title": "Kiwi needs your answer", "body": "Which database should I use? (+1 more)",
              "tab": "● kiwi – waiting for you"},
             {"title": "Kiwi finished", "body": "Done", "tab": "✓ kiwi – done"},
+            {"title": "Kiwi run failed", "body": "Tool call timed out", "tab": "✗ kiwi – failed"},
         ]
 
         # In kiwi already: a question is pointed out on the screen instead.
@@ -137,3 +139,34 @@ async def test_a_waiting_question_names_itself_and_a_finished_run_its_answer(mon
         screen._call_for_attention("question")
         await pilot.pause(0.05)
         assert any("waiting for your answer" in str(n.message) for n in app._notifications)
+
+
+class _FailedRunClient:
+    def get_action_result(self, run_id):
+        return True, {"id": run_id, "status": "failed", "message": "Tool call timed out\nTraceback …"}, ""
+
+    def get_run_activity(self, run_id):
+        return 200, []
+
+    async def stream_action_result(self, run_id, on_message, **kwargs):
+        import asyncio
+
+        on_message({"type": "turn.started", "src": "w", "seq": 1, "at": 1, "name": "agent"})
+        on_message({"type": "turn.finished", "src": "w", "seq": 2, "at": 2, "ok": False, "error": "failed"})
+        await asyncio.sleep(3600)
+
+
+async def test_a_run_that_fails_while_followed_calls_the_user_back() -> None:
+    import asyncio
+
+    from tests.test_term_dashboard_ui import _TermDashboardTestApp
+
+    app = _TermDashboardTestApp()
+    async with app.run_test(size=(100, 30)) as pilot:
+        await pilot.pause(0.05)
+        calls: list[dict] = []
+        app.call_for_attention = lambda **kw: calls.append(kw) or True
+        app.screen._set_run_inflight(True)
+        await asyncio.wait_for(app.screen._consume_sse("run-1", _FailedRunClient()), timeout=10)
+
+    assert calls == [{"title": "Kiwi run failed", "body": "Tool call timed out", "tab": "✗ kiwi – failed"}]