kiwi-code 0.0.30__tar.gz → 0.0.32__tar.gz

{kiwi_code-0.0.30 → kiwi_code-0.0.32}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.30"
+version = "0.0.32"
 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.30 → kiwi_code-0.0.32}/src/kiwi_cli/cli.py

@@ -1,6 +1,6 @@
 """Typer CLI for Autobots — thin wrapper over commands.py."""
 
-from typing import Optional
+from typing import Optional, Callable
 
 from loguru import logger
 logger.remove()  # Suppress loguru console output in CLI mode
@@ -55,18 +55,92 @@ def _backend_url() -> str:
     return AppConfig().backend_url
 
 
+def _http_status_from_lines(lines: list[str]) -> int | None:
+    """Extract an HTTP status code from commands.py output lines.
+
+    commands.py returns errors in the form: ["Error: HTTP <code>"]
+    """
+    if not lines:
+        return None
+    if len(lines) != 1:
+        return None
+    s = lines[0].strip()
+    prefix = "Error: HTTP "
+    if not s.startswith(prefix):
+        return None
+    try:
+        return int(s[len(prefix):].strip())
+    except Exception:
+        return None
+
+
+def _force_refresh_tokens(tm: TokenManager) -> bool:
+    """Force refresh tokens once and persist them."""
+    from .client import AutobotsClientWrapper
+
+    with tm.file_lock():
+        tokens = tm.load_tokens()
+        if not tokens:
+            return False
+        refresh = getattr(tokens, "refresh_token", None)
+        if not refresh:
+            return False
+
+        wrapper = AutobotsClientWrapper(
+            base_url=_backend_url(),
+            access_token=getattr(tokens, "access_token", None),
+        )
+        ok, new_tokens, _msg = wrapper.refresh_token(str(refresh))
+        if ok and new_tokens:
+            tm.save_tokens(new_tokens)
+            return True
+        return False
+
+
 def _get_client() -> AuthenticatedClient:
+    """Get an authenticated OpenAPI client.
+
+    If the access token is expired but a refresh token exists, attempt a refresh
+    once. This improves CLI reliability for long-lived sessions.
+    """
     tm = TokenManager()
-    if not tm.is_authenticated():
+    tokens = tm.load_tokens()
+    if not tokens:
+        typer.echo("Not authenticated. Run `kiwi login` first.", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        if tokens.is_expired() and getattr(tokens, "refresh_token", None):
+            _force_refresh_tokens(tm)
+            tokens = tm.load_tokens() or tokens
+    except Exception:
+        pass
+
+    access = getattr(tokens, "access_token", None)
+    if not access:
         typer.echo("Not authenticated. Run `kiwi login` first.", err=True)
         raise typer.Exit(code=1)
+
     return AuthenticatedClient(
         base_url=_backend_url(),
-        token=tm.get_access_token(),
+        token=str(access),
         raise_on_unexpected_status=False,
     )
 
 
+def _run_with_refresh_retry(run: Callable[[AuthenticatedClient], list[str]]) -> list[str]:
+    """Run a CLI command with one forced refresh retry on 401/403."""
+    tm = TokenManager()
+    lines = run(_get_client())
+    code = _http_status_from_lines(lines)
+    if code in (401, 403):
+        try:
+            if _force_refresh_tokens(tm):
+                lines = run(_get_client())
+        except Exception:
+            pass
+    return lines
+
 def _print(lines: list[str]) -> None:
     for line in lines:
         typer.echo(line)
@@ -81,12 +155,12 @@ def actions_list_cmd(
     offset: int = typer.Option(0, help="Offset"),
 ):
     """List actions."""
-    _print(commands.actions_list(_get_client(), name=name, limit=limit, offset=offset))
+    _print(_run_with_refresh_retry(lambda c: commands.actions_list(c, name=name, limit=limit, offset=offset)))
 
 @actions_app.command("get")
 def actions_get_cmd(id: str = typer.Argument(help="Action ID")):
     """Get action details."""
-    _print(commands.actions_get(_get_client(), id=id))
+    _print(_run_with_refresh_retry(lambda c: commands.actions_get(c, id=id)))
 
 
 # -- runs -------------------------------------------------------------------
@@ -100,12 +174,12 @@ def runs_list_cmd(
     offset: int = typer.Option(0, help="Offset"),
 ):
     """List action runs (results)."""
-    _print(commands.runs_list(_get_client(), action_id=action_id, action_name=action_name, status=status, limit=limit, offset=offset))
+    _print(_run_with_refresh_retry(lambda c: commands.runs_list(c, action_id=action_id, action_name=action_name, status=status, limit=limit, offset=offset)))
 
 @action_runs_app.command("get")
 def runs_get_cmd(id: str = typer.Argument(help="Action run ID")):
     """Get action run details."""
-    _print(commands.runs_get(_get_client(), id=id))
+    _print(_run_with_refresh_retry(lambda c: commands.runs_get(c, id=id)))
 
 
 # -- graphs -----------------------------------------------------------------
@@ -117,12 +191,12 @@ def graphs_list_cmd(
     offset: int = typer.Option(0, help="Offset"),
 ):
     """List action graphs."""
-    _print(commands.graphs_list(_get_client(), name=name, limit=limit, offset=offset))
+    _print(_run_with_refresh_retry(lambda c: commands.graphs_list(c, name=name, limit=limit, offset=offset)))
 
 @graphs_app.command("get")
 def graphs_get_cmd(id: str = typer.Argument(help="Action graph ID")):
     """Get action graph details."""
-    _print(commands.graphs_get(_get_client(), id=id))
+    _print(_run_with_refresh_retry(lambda c: commands.graphs_get(c, id=id)))
 
 
 # -- graph-runs -------------------------------------------------------------
@@ -136,12 +210,12 @@ def graph_runs_list_cmd(
     offset: int = typer.Option(0, help="Offset"),
 ):
     """List action graph runs (results)."""
-    _print(commands.graph_runs_list(_get_client(), action_graph_id=graph_id, action_graph_name=graph_name, status=status, limit=limit, offset=offset))
+    _print(_run_with_refresh_retry(lambda c: commands.graph_runs_list(c, action_graph_id=graph_id, action_graph_name=graph_name, status=status, limit=limit, offset=offset)))
 
 @graph_runs_app.command("get")
 def graph_runs_get_cmd(id: str = typer.Argument(help="Graph run ID")):
     """Get action graph run details."""
-    _print(commands.graph_runs_get(_get_client(), id=id))
+    _print(_run_with_refresh_retry(lambda c: commands.graph_runs_get(c, id=id)))
 
 
 # -- runtime ----------------------------------------------------------------

{kiwi_code-0.0.30 → kiwi_code-0.0.32}/src/kiwi_cli/client.py

@@ -183,7 +183,14 @@ class AutobotsClientWrapper:
             # even if `refresh_token` is provided as a query param.
             url = f"{self.base_url.rstrip('/')}/v1/auth/session/refresh"
             with httpx.Client(timeout=30) as client:
-                resp = client.post(url, params={"refresh_token": refresh_token})
+                # Best-effort: send the (possibly expired) access token for anomaly tracking.
+                # The backend refresh endpoint must not *require* it.
+                headers: dict[str, str] = {}
+                if self.access_token:
+                    headers["Authorization"] = f"Bearer {self.access_token}"
+                resp = client.post(
+                    url, params={"refresh_token": refresh_token}, headers=headers
+                )
 
             if resp.status_code != 200:
                 detail = (resp.text or "").strip()

{kiwi_code-0.0.30 → kiwi_code-0.0.32}/src/kiwi_tui/screens/dashboard.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from typing import Callable
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.screen import Screen
@@ -720,6 +721,36 @@ class DashboardScreen(Screen):
             def show(body: str, *, is_error: bool = False, title: str | None = None) -> None:
                 self._show_command_result(title or command, body, is_error=is_error)
 
+            def toast(
+                message: str,
+                *,
+                severity: "SeverityLevel" = "information",
+                title: str = "",
+                timeout: float | None = 2.5,
+            ) -> None:
+                """Show a non-blocking toast notification.
+
+                Preferred for slash commands where the user doesn't need a full modal
+                (e.g. /new, /use, /continue).
+                """
+                try:
+                    # Screen inherits Widget, which provides notify() (delegates to App.notify).
+                    self.notify(
+                        message,
+                        title=title,
+                        severity=severity,
+                        timeout=timeout,
+                        markup=False,
+                    )
+                except Exception:
+                    # If toast notifications fail for any reason, fall back to the modal so
+                    # the user still gets feedback.
+                    self._show_command_result(
+                        title or command, message, is_error=severity == "error"
+                    )
+
+
+
             # --- TUI-specific commands ---
 
             if cmd == "/upload":
@@ -870,58 +901,62 @@ class DashboardScreen(Screen):
                 self.current_run_kind = None
                 self._update_run_status_bar()
                 self._clear_chat_messages()
-                show(f"Starting new conversation with default action ({self.DEFAULT_ACTION_ID}).")
+                toast("Started a new conversation.", title="/new")
                 return
             if cmd == "/use":
                 if not args:
-                    show("Usage: /use <action_id>")
+                    toast("Usage: /use <action_id>", title="/use", severity="warning")
                     return
                 action_id = args[0]
-                api_client = self._get_api_client_for_command(command)
-                if not api_client:
-                    return
                 from kiwi_cli.commands import actions_get
-                lines = await asyncio.to_thread(lambda: actions_get(api_client, id=action_id))
+                lines = await self._run_lines_with_refresh_retry(
+                    command, lambda c: actions_get(c, id=action_id)
+                )
+                if lines is None:
+                    return
                 if lines and lines[0].startswith("Error"):
-                    show(f"Action not found: {action_id}", is_error=True)
+                    toast(f"Action not found: {action_id}", title="/use", severity="error")
                     return
                 self.current_action_id = action_id
                 self.current_run_id = None
                 self.current_run_kind = None
                 self._update_run_status_bar()
                 self._clear_chat_messages()
-                show("\n".join(["Switched to action:"] + lines))
+                toast(f"Switched to action {action_id}.", title="/use")
                 return
 
             if cmd == "/continue":
                 if not args:
-                    show("Usage: /continue <run_id>")
+                    toast("Usage: /continue <run_id>", title="/continue", severity="warning")
                     return
                 run_id = args[0]
-                api_client = self._get_api_client_for_command(command)
-                if not api_client:
-                    return
                 from kiwi_cli.commands import runs_get
-                lines = await asyncio.to_thread(lambda: runs_get(api_client, id=run_id))
+                lines = await self._run_lines_with_refresh_retry(
+                    command, lambda c: runs_get(c, id=run_id)
+                )
+                if lines is None:
+                    return
                 if lines and lines[0].startswith("Error"):
-                    show(f"Run not found: {run_id}", is_error=True)
+                    toast(f"Run not found: {run_id}", title="/continue", severity="error")
                     return
                 self.current_run_id = run_id
                 self.current_run_kind = "action"
                 self._update_run_status_bar()
-                show("\n".join(["Continuing run:"] + lines))
+                toast(f"Continuing run {run_id}...", title="/continue")
                 await self._load_conversation_history_async(run_id)
                 return
 
             if cmd == "/name":
                 new_name = " ".join(args).strip()
                 if not new_name:
-                    show("Usage: /name <new name>")
+                    toast("Usage: /name <new name>", title="/name", severity="warning")
                     return
                 if not self.current_run_id:
-                    show(
-                        "Error: no run id yet. Start a conversation (send a message), or use /continue <run_id>, or pick one from /runs list.",
-                        is_error=True,
+                    toast(
+                        "No run id yet. Send a message to start a run, or use /continue <run_id> (or pick one from /runs list).",
+                        title="/name",
+                        severity="error",
+                        timeout=4,
                     )
                     return
 
@@ -987,10 +1022,15 @@ class DashboardScreen(Screen):
 
                 if status_code != 200:
                     details = err or ""
-                    show(
-                        f"Error: failed to rename run {run_id}. Tried: {', '.join(tried)}. HTTP {status_code}. {details}",
-                        is_error=True,
-                    )
+                    # Keep this as a toast (non-blocking). Truncate details to avoid huge toasts.
+                    details_short = (details or "").strip().replace("\n", " ")
+                    if len(details_short) > 160:
+                        details_short = details_short[:157] + "..."
+                    msg = f"Failed to rename run {run_id} (HTTP {status_code})."
+                    if details_short:
+                        msg += f" {details_short}"
+                    toast(msg, title="/name", severity="error", timeout=5)
+
                     return
 
                 # Best-effort: update local cached run name (used by the quit-time cleanup prompt).
@@ -1006,7 +1046,7 @@ class DashboardScreen(Screen):
                 except Exception:
                     pass
 
-                show(f"Renamed run {run_id} to: {new_name}")
+                toast(f"Renamed run {run_id} to: {new_name}", title="/name", timeout=4)
                 return
 
             if cmd == "/status":
@@ -1056,7 +1096,11 @@ class DashboardScreen(Screen):
 
             from kiwi_cli.commands import dispatch
             try:
-                lines = await asyncio.to_thread(lambda: dispatch(command, api_client))
+                lines = await self._run_lines_with_refresh_retry(
+                    command, lambda c: dispatch(command, c)
+                )
+                if lines is None:
+                    return
                 show("\n".join(lines))
             except Exception as e:
                 show(f"Command error: {e}", is_error=True)
@@ -1070,9 +1114,26 @@ class DashboardScreen(Screen):
         """Fetch and render conversation history without blocking the UI."""
         if not hasattr(self.app, "autobots_client"):
             return
-        success, result, _msg = await asyncio.to_thread(
+        success, result, msg = await asyncio.to_thread(
             lambda: self.app.autobots_client.get_action_result(run_id)
         )
+        if (not success) and msg:
+            code = None
+            try:
+                m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(msg))
+                if m:
+                    code = int(m.group(1))
+            except Exception:
+                code = None
+            if code in (401, 403):
+                try:
+                    refreshed = bool(self.app._refresh_token_if_needed(force=True))
+                except Exception:
+                    refreshed = False
+                if refreshed:
+                    success, result, msg = await asyncio.to_thread(
+                        lambda: self.app.autobots_client.get_action_result(run_id)
+                    )
         if not success or not result:
             return
         self._render_conversation_history_from_action_result(result)
@@ -1093,6 +1154,22 @@ class DashboardScreen(Screen):
                 offset=offset,
             )
         )
+        if resp.status_code in (401, 403):
+            # Reactive auth guard: force refresh and retry once.
+            try:
+                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+            except Exception:
+                refreshed = False
+            if refreshed:
+                api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
+                resp = await asyncio.to_thread(
+                    lambda: list_actions_v1_actions_get.sync_detailed(
+                        client=api_client,
+                        name=name if name else UNSET,
+                        limit=limit,
+                        offset=offset,
+                    )
+                )
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1147,6 +1224,23 @@ class DashboardScreen(Screen):
                 offset=int(opts.get("offset", "0")),
             )
         )
+        if resp.status_code in (401, 403):
+            try:
+                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+            except Exception:
+                refreshed = False
+            if refreshed:
+                api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
+                resp = await asyncio.to_thread(
+                    lambda: list_action_result_v1_action_results_get.sync_detailed(
+                        client=api_client,
+                        action_id=opts.get("action_id") or UNSET,
+                        action_name=opts.get("action_name") or UNSET,
+                        status=status_enum,
+                        limit=int(opts.get("limit", "50")),
+                        offset=int(opts.get("offset", "0")),
+                    )
+                )
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1188,6 +1282,21 @@ class DashboardScreen(Screen):
                 offset=offset,
             )
         )
+        if resp.status_code in (401, 403):
+            try:
+                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+            except Exception:
+                refreshed = False
+            if refreshed:
+                api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
+                resp = await asyncio.to_thread(
+                    lambda: list_action_graphs_v1_action_graphs_get.sync_detailed(
+                        client=api_client,
+                        name=name if name else UNSET,
+                        limit=limit,
+                        offset=offset,
+                    )
+                )
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1242,6 +1351,23 @@ class DashboardScreen(Screen):
                 offset=int(opts.get("offset", "0")),
             )
         )
+        if resp.status_code in (401, 403):
+            try:
+                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+            except Exception:
+                refreshed = False
+            if refreshed:
+                api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
+                resp = await asyncio.to_thread(
+                    lambda: list_action_graph_result_v1_action_graphs_results_get.sync_detailed(
+                        client=api_client,
+                        action_graph_id=opts.get("graph_id") or UNSET,
+                        action_graph_name=opts.get("graph_name") or UNSET,
+                        status=status_enum,
+                        limit=int(opts.get("limit", "50")),
+                        offset=int(opts.get("offset", "0")),
+                    )
+                )
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1302,6 +1428,47 @@ class DashboardScreen(Screen):
         return api_client
 
 
+
+    def _http_status_from_lines(self, lines: list[str]) -> int | None:
+        """Extract status code from a commands.py-style error list."""
+        if not lines:
+            return None
+        if len(lines) != 1:
+            return None
+        s = str(lines[0]).strip()
+        m = re.match(r"^Error:\s*HTTP\s*(\d{3})\s*$", s)
+        if not m:
+            return None
+        try:
+            return int(m.group(1))
+        except Exception:
+            return None
+
+
+    async def _run_lines_with_refresh_retry(
+        self,
+        title: str,
+        fn: Callable[[object], list[str]],
+    ) -> list[str] | None:
+        """Run a slash-command lines function with one refresh+retry on 401/403."""
+        api_client = self._get_api_client_for_command(title)
+        if not api_client:
+            return None
+        lines = await asyncio.to_thread(lambda: fn(api_client))
+        code = self._http_status_from_lines(lines)
+        if code in (401, 403):
+            refreshed = False
+            try:
+                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+            except Exception:
+                refreshed = False
+            if refreshed:
+                api_client = self._get_api_client_for_command(title)
+                if not api_client:
+                    return lines
+                lines = await asyncio.to_thread(lambda: fn(api_client))
+        return lines
+
     def _parse_command_opts(self, command: str, skip: int = 2) -> dict[str, str]:
         """Parse --key value pairs from a slash command string."""
         parts = command.strip().split()
@@ -1543,11 +1710,12 @@ class DashboardScreen(Screen):
 
     async def _on_action_picked_async(self, action_id: str) -> None:
         try:
-            api_client = self._get_api_client_for_command("/actions list")
-            if not api_client:
-                return
             from kiwi_cli.commands import actions_get
-            lines = await asyncio.to_thread(lambda: actions_get(api_client, id=action_id))
+            lines = await self._run_lines_with_refresh_retry(
+                "/actions list", lambda c: actions_get(c, id=action_id)
+            )
+            if lines is None:
+                return
             if lines and lines[0].startswith("Error"):
                 self._show_command_result("Action selection", f"Action not found: {action_id}", is_error=True)
                 return
@@ -1578,11 +1746,12 @@ class DashboardScreen(Screen):
 
     async def _on_run_picked_async(self, run_id: str) -> None:
         try:
-            api_client = self._get_api_client_for_command("/runs list")
-            if not api_client:
-                return
             from kiwi_cli.commands import runs_get
-            lines = await asyncio.to_thread(lambda: runs_get(api_client, id=run_id))
+            lines = await self._run_lines_with_refresh_retry(
+                "/runs list", lambda c: runs_get(c, id=run_id)
+            )
+            if lines is None:
+                return
             if lines and lines[0].startswith("Error"):
                 self._show_command_result("Run selection", f"Run not found: {run_id}", is_error=True)
                 return
@@ -1612,11 +1781,12 @@ class DashboardScreen(Screen):
 
     async def _on_graph_picked_async(self, graph_id: str) -> None:
         try:
-            api_client = self._get_api_client_for_command("/graphs list")
-            if not api_client:
-                return
             from kiwi_cli.commands import graphs_get
-            lines = await asyncio.to_thread(lambda: graphs_get(api_client, id=graph_id))
+            lines = await self._run_lines_with_refresh_retry(
+                "/graphs list", lambda c: graphs_get(c, id=graph_id)
+            )
+            if lines is None:
+                return
             if lines and lines[0].startswith("Error"):
                 self._show_command_result("Graph selection", f"Graph not found: {graph_id}", is_error=True)
                 return
@@ -1642,11 +1812,12 @@ class DashboardScreen(Screen):
 
     async def _on_graph_run_picked_async(self, graph_run_id: str) -> None:
         try:
-            api_client = self._get_api_client_for_command("/graph-runs list")
-            if not api_client:
-                return
             from kiwi_cli.commands import graph_runs_get
-            lines = await asyncio.to_thread(lambda: graph_runs_get(api_client, id=graph_run_id))
+            lines = await self._run_lines_with_refresh_retry(
+                "/graph-runs list", lambda c: graph_runs_get(c, id=graph_run_id)
+            )
+            if lines is None:
+                return
             if lines and lines[0].startswith("Error"):
                 self._show_command_result("Graph run selection", f"Graph run not found: {graph_run_id}", is_error=True)
                 return
@@ -2188,17 +2359,48 @@ class DashboardScreen(Screen):
             return
 
         if not success:
-            self.add_message(f"Error starting action: {message}", "error")
-            # Remove the placeholder row (no run was started).
+            # Reactive auth guard: if the request failed with 401/403, force a token
+            # refresh and retry once before surfacing the error.
+            code = None
             try:
-                w = getattr(self, "_streaming_widget_ref", None)
-                if w:
-                    w.remove()
+                m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(message or ""))
+                if m:
+                    code = int(m.group(1))
             except Exception:
-                pass
-            self._streaming_widget_ref = None
-            self._set_streaming(False)
-            return
+                code = None
+
+            if code in (401, 403):
+                try:
+                    refreshed = bool(self.app._refresh_token_if_needed(force=True))
+                except Exception:
+                    refreshed = False
+                if refreshed:
+                    try:
+                        success, run_id, message = await loop.run_in_executor(
+                            None,
+                            lambda: client.run_action_async(
+                                self.current_action_id,
+                                user_input,
+                                action_result_id=self.current_run_id,
+                                urls=urls if urls else None,
+                                metadata=self._metadata if self._metadata else None,
+                            ),
+                        )
+                    except Exception:
+                        pass
+
+            if not success:
+                self.add_message(f"Error starting action: {message}", "error")
+                # Remove the placeholder row (no run was started).
+                try:
+                    w = getattr(self, "_streaming_widget_ref", None)
+                    if w:
+                        w.remove()
+                except Exception:
+                    pass
+                self._streaming_widget_ref = None
+                self._set_streaming(False)
+                return
 
         # Check if this is continuing an existing conversation
         if self.current_run_id and run_id == self.current_run_id:
@@ -2312,17 +2514,51 @@ class DashboardScreen(Screen):
             if got_final_result:
                 return True
 
+            auth_failed_code: int | None = None
+
             try:
                 async with fetch_lock:
                     if got_final_result:
                         return True
-                    success, final_result, _message = await asyncio.to_thread(
+                    success, final_result, message = await asyncio.to_thread(
                         client.get_action_result, run_id
                     )
+
+                    if not success:
+                        code = None
+                        try:
+                            m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(message or ""))
+                            if m:
+                                code = int(m.group(1))
+                        except Exception:
+                            code = None
+
+                        if code in (401, 403):
+                            try:
+                                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+                            except Exception:
+                                refreshed = False
+                            if refreshed:
+                                success, final_result, message = await asyncio.to_thread(
+                                    client.get_action_result, run_id
+                                )
+                        if (not success) and (code in (401, 403)):
+                            auth_failed_code = code
             except Exception as e:
                 logger.warning(f"Poll error: {e}")
                 return False
 
+
+            if auth_failed_code in (401, 403):
+                self.add_message(
+                    f"Authentication error while fetching result (HTTP {auth_failed_code}). Please /login again.",
+                    "error",
+                )
+                got_final_result = True
+                # Stop spinner/blink immediately when we have a terminal state.
+                self._set_streaming(False)
+                return True
+
             if not success or not final_result:
                 return False
 
@@ -2613,7 +2849,22 @@ class DashboardScreen(Screen):
         """
         if not hasattr(self.app, "autobots_client"):
             return
-        success, result, _msg = self.app.autobots_client.get_action_result(run_id)
+        success, result, msg = self.app.autobots_client.get_action_result(run_id)
+        if (not success) and msg:
+            code = None
+            try:
+                m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(msg))
+                if m:
+                    code = int(m.group(1))
+            except Exception:
+                code = None
+            if code in (401, 403):
+                try:
+                    refreshed = bool(self.app._refresh_token_if_needed(force=True))
+                except Exception:
+                    refreshed = False
+                if refreshed:
+                    success, result, msg = self.app.autobots_client.get_action_result(run_id)
         if not success or not result:
             return
         self._render_conversation_history_from_action_result(result)

{kiwi_code-0.0.30 → kiwi_code-0.0.32}/uv.lock

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