kiwi-code 0.0.41__tar.gz → 0.0.43__tar.gz

{kiwi_code-0.0.41 → kiwi_code-0.0.43}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.41"
+version = "0.0.43"
 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.41 → kiwi_code-0.0.43}/src/kiwi_tui/main.py

@@ -610,11 +610,12 @@ class AutobotsTUI(App):
         #     runtime_manager.save_refresh_token(tokens.refresh_token)
 
     def _refresh_token_if_needed(self, force: bool = False) -> bool:
-        """Synchronize auth state from disk and refresh only when needed.
+        """Synchronize auth state from disk and refresh when needed.
 
         Args:
-            force: If True, re-check disk state immediately and refresh only if
-                the shared on-disk access token is still expired.
+            force: If True, attempt a refresh-token exchange immediately even if
+                the current access token does not appear expired on disk. This is
+                used after an HTTP 401/403 from the server.
         """
         with self.token_manager.file_lock():
             tokens = self.token_manager.load_tokens()
@@ -622,7 +623,7 @@ class AutobotsTUI(App):
                 logger.debug("No tokens to refresh")
                 return False
 
-            if not tokens.is_expired():
+            if not force and not tokens.is_expired():
                 logger.debug("Token on disk is valid; synchronizing in-memory auth state")
                 if getattr(tokens, "access_token", None):
                     self.autobots_client.update_token(tokens.access_token)
@@ -683,6 +684,55 @@ class AutobotsTUI(App):
         except Exception:
             pass
 
+    def _handle_auth_expired(self, reason: str | None = None) -> None:
+        """Clear auth state and return the user to the login screen.
+
+        Used when the server rejects the current session (401/403) and a forced
+        token refresh cannot recover it.
+        """
+        logger.warning(f"Authentication expired; redirecting to login. Reason: {reason or 'unknown'}")
+
+        try:
+            screen = self.screen
+            if hasattr(screen, "reset_for_auth_expired"):
+                screen.reset_for_auth_expired()
+        except Exception:
+            pass
+
+        timer = getattr(self, "_token_refresh_timer", None)
+        if timer is not None:
+            try:
+                timer.stop()
+            except Exception:
+                pass
+            self._token_refresh_timer = None
+
+        self.pending_runtime_id = None
+        self.token_manager.clear_tokens()
+        self._kiwi_token = None
+
+        self.autobots_client = AutobotsClientWrapper(
+            base_url=self.config.backend_url,
+            api_key=self.config.api_key,
+        )
+
+        try:
+            already_on_login = type(self.screen).__name__ == "LoginScreen"
+        except Exception:
+            already_on_login = False
+
+        if not already_on_login:
+            try:
+                self.switch_screen("login")
+            except IndexError:
+                self.push_screen("login")
+
+        self.notify(
+            reason or "Your session expired. Please log in again.",
+            severity="error",
+            title="Authentication required",
+        )
+
     def action_logout(self) -> None:
         """Logout user and return to login screen."""
         logger.info("User logout requested")

{kiwi_code-0.0.41 → kiwi_code-0.0.43}/src/kiwi_tui/screens/dashboard.py

@@ -138,6 +138,7 @@ class DashboardScreen(Screen):
         "69c2180355a89324a9926bc6",
         "6a0625b8ab5f80ba8ac5d012",
         "69e4be0d70c2d7a89197e66e",
+        "6a1c0773c519da8a0fa9b8a4",
     ]
 
     BINDINGS = [
@@ -600,6 +601,27 @@ class DashboardScreen(Screen):
         action_w.update(f"Action: {action_label}")
         run_w.update(f"Run: {run_id}")
 
+
+    def _refresh_auth_or_redirect(self, code: int | None, *, context: str) -> bool:
+        """Try one forced auth refresh after a 401/403.
+
+        Returns True only when a forced refresh succeeded and the caller should
+        retry the original request once. If refresh itself fails, auth is already
+        unrecoverable for this request and the user is redirected to login.
+        """
+        if code not in (401, 403):
+            return False
+
+        try:
+            refreshed = bool(self.app._refresh_token_if_needed(force=True))
+        except Exception:
+            refreshed = False
+
+        if not refreshed:
+            self.app._handle_auth_expired(
+                f"Authentication expired while {context} (HTTP {code}). Please log in again."
+            )
+        return refreshed
     async def _refresh_current_action_name_async(self) -> None:
         """Best-effort fetch of the current action name for the status bar."""
         from autobots_client.api.actions import get_action_v1_actions_id_get
@@ -614,13 +636,18 @@ class DashboardScreen(Screen):
 
         resp = await asyncio.to_thread(lambda: _fetch(api_client))
         if resp.status_code in (401, 403):
-            try:
-                refreshed = bool(self.app._refresh_token_if_needed(force=True))
-            except Exception:
-                refreshed = False
+            refreshed = self._refresh_auth_or_redirect(
+                resp.status_code,
+                context="refreshing the current action name",
+            )
             if refreshed:
                 api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
                 resp = await asyncio.to_thread(lambda: _fetch(api_client))
+                if resp.status_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while refreshing the current action name (HTTP {resp.status_code}). Please log in again."
+                    )
+                    return
 
         if requested_action_id != self.current_action_id:
             return
@@ -1261,14 +1288,27 @@ class DashboardScreen(Screen):
             except Exception:
                 code = None
             if code in (401, 403):
-                try:
-                    refreshed = bool(self.app._refresh_token_if_needed(force=True))
-                except Exception:
-                    refreshed = False
+                refreshed = self._refresh_auth_or_redirect(
+                    code,
+                    context="loading conversation history",
+                )
                 if refreshed:
                     success, result, msg = await asyncio.to_thread(
                         lambda: self.app.autobots_client.get_action_result(run_id)
                     )
+                    if (not success) and msg:
+                        retry_code = None
+                        try:
+                            m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(msg))
+                            if m:
+                                retry_code = int(m.group(1))
+                        except Exception:
+                            retry_code = None
+                        if retry_code in (401, 403):
+                            self.app._handle_auth_expired(
+                                f"Authentication expired while loading conversation history (HTTP {retry_code}). Please log in again."
+                            )
+                            return
         if not success or not result:
             return
         self._update_action_context_from_action_result(result)
@@ -1309,10 +1349,10 @@ class DashboardScreen(Screen):
             for action_id in self.AUTOCODE_ACTION_IDS
         ]
         if any(resp.status_code in (401, 403) for _, resp in responses):
-            try:
-                refreshed = bool(self.app._refresh_token_if_needed(force=True))
-            except Exception:
-                refreshed = False
+            refreshed = self._refresh_auth_or_redirect(
+                401,
+                context="loading the available AutoCode actions",
+            )
             if refreshed:
                 api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
 
@@ -1325,6 +1365,11 @@ class DashboardScreen(Screen):
                     (action_id, await _fetch_action_refreshed(action_id))
                     for action_id in self.AUTOCODE_ACTION_IDS
                 ]
+                if any(resp.status_code in (401, 403) for _, resp in responses):
+                    self.app._handle_auth_expired(
+                        "Authentication expired while loading the available AutoCode actions. Please log in again."
+                    )
+                    return
 
         rows: list[tuple[str, list[str]]] = []
         unavailable: list[str] = []
@@ -1377,10 +1422,10 @@ class DashboardScreen(Screen):
         )
         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
+            refreshed = self._refresh_auth_or_redirect(
+                resp.status_code,
+                context="listing actions",
+            )
             if refreshed:
                 api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
                 resp = await asyncio.to_thread(
@@ -1391,6 +1436,11 @@ class DashboardScreen(Screen):
                         offset=offset,
                     )
                 )
+                if resp.status_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while listing actions (HTTP {resp.status_code}). Please log in again."
+                    )
+                    return
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1446,10 +1496,10 @@ class DashboardScreen(Screen):
             )
         )
         if resp.status_code in (401, 403):
-            try:
-                refreshed = bool(self.app._refresh_token_if_needed(force=True))
-            except Exception:
-                refreshed = False
+            refreshed = self._refresh_auth_or_redirect(
+                resp.status_code,
+                context="listing runs",
+            )
             if refreshed:
                 api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
                 resp = await asyncio.to_thread(
@@ -1462,6 +1512,11 @@ class DashboardScreen(Screen):
                         offset=int(opts.get("offset", "0")),
                     )
                 )
+                if resp.status_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while listing runs (HTTP {resp.status_code}). Please log in again."
+                    )
+                    return
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1504,10 +1559,10 @@ class DashboardScreen(Screen):
             )
         )
         if resp.status_code in (401, 403):
-            try:
-                refreshed = bool(self.app._refresh_token_if_needed(force=True))
-            except Exception:
-                refreshed = False
+            refreshed = self._refresh_auth_or_redirect(
+                resp.status_code,
+                context="listing graphs",
+            )
             if refreshed:
                 api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
                 resp = await asyncio.to_thread(
@@ -1518,6 +1573,11 @@ class DashboardScreen(Screen):
                         offset=offset,
                     )
                 )
+                if resp.status_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while listing graphs (HTTP {resp.status_code}). Please log in again."
+                    )
+                    return
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1573,10 +1633,10 @@ class DashboardScreen(Screen):
             )
         )
         if resp.status_code in (401, 403):
-            try:
-                refreshed = bool(self.app._refresh_token_if_needed(force=True))
-            except Exception:
-                refreshed = False
+            refreshed = self._refresh_auth_or_redirect(
+                resp.status_code,
+                context="listing graph runs",
+            )
             if refreshed:
                 api_client = getattr(getattr(self.app, "autobots_client", None), "client", api_client)
                 resp = await asyncio.to_thread(
@@ -1589,6 +1649,11 @@ class DashboardScreen(Screen):
                         offset=int(opts.get("offset", "0")),
                     )
                 )
+                if resp.status_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while listing graph runs (HTTP {resp.status_code}). Please log in again."
+                    )
+                    return
         if resp.status_code != 200 or not resp.parsed:
             self._show_command_result(command, f"Error: HTTP {resp.status_code}", is_error=True)
             return
@@ -1678,16 +1743,21 @@ class DashboardScreen(Screen):
         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
+            refreshed = self._refresh_auth_or_redirect(
+                code,
+                context=f"running {title}",
+            )
             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))
+                retry_code = self._http_status_from_lines(lines)
+                if retry_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while running {title} (HTTP {retry_code}). Please log in again."
+                    )
+                    return lines
         return lines
 
     def _parse_command_opts(self, command: str, skip: int = 2) -> dict[str, str]:
@@ -2282,6 +2352,50 @@ class DashboardScreen(Screen):
                 pass
         messages.scroll_end(animate=False)
 
+
+    def reset_for_auth_expired(self) -> None:
+        """Clear transient dashboard state before redirecting to login."""
+        try:
+            for worker in self.workers:
+                if not worker.is_finished:
+                    worker.cancel()
+        except Exception:
+            pass
+
+        try:
+            self._set_streaming(False)
+        except Exception:
+            pass
+
+        try:
+            w = getattr(self, "_streaming_widget_ref", None)
+            if w:
+                w.remove()
+        except Exception:
+            pass
+        self._streaming_widget_ref = None
+
+        self.current_run_id = None
+        self.current_run_kind = None
+        self._pending_urls.clear()
+        self._upload_status_text = ""
+        try:
+            self._update_pending_files_bar()
+        except Exception:
+            pass
+        try:
+            self._update_run_status_bar()
+        except Exception:
+            pass
+
+        try:
+            chat_input = self.query_one("#chat-input", ChatInput)
+            chat_input.value = ""
+            chat_input.focus()
+        except Exception:
+            pass
+
+        self._clear_chat_messages()
     def add_message(self, text: str, msg_type: str = "assistant") -> None:
         """Add a message to the chat."""
         messages = self.query_one("#messages", VerticalScroll)
@@ -2581,10 +2695,21 @@ class DashboardScreen(Screen):
                     refreshed = bool(await asyncio.to_thread(self.app._refresh_token_if_needed, True))
                 except Exception:
                     refreshed = False
-                if refreshed:
-                    success, urls, message = await asyncio.to_thread(
-                        lambda: self.app.autobots_client.upload_files(file_paths)
+                if not refreshed:
+                    self.app._handle_auth_expired(
+                        "Authentication expired while uploading files. Please log in again."
+                    )
+                    self._set_upload_status("")
+                    return
+                success, urls, message = await asyncio.to_thread(
+                    lambda: self.app.autobots_client.upload_files(file_paths)
+                )
+                if (not success) and ("HTTP 401" in message or "HTTP 403" in message):
+                    self.app._handle_auth_expired(
+                        "Authentication expired while uploading files. Please log in again."
                     )
+                    self._set_upload_status("")
+                    return
 
             if success:
                 self._pending_urls.extend(urls)
@@ -2779,25 +2904,58 @@ class DashboardScreen(Screen):
             except Exception:
                 code = None
 
+            retried_after_auth = False
             if code in (401, 403):
+                refreshed = self._refresh_auth_or_redirect(
+                    code,
+                    context="starting an action",
+                )
+                if not refreshed:
+                    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
+                retried_after_auth = True
                 try:
-                    refreshed = bool(self.app._refresh_token_if_needed(force=True))
+                    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:
-                    refreshed = False
-                if refreshed:
+                    pass
+
+            if retried_after_auth and not success:
+                retry_code = None
+                try:
+                    m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(message or ""))
+                    if m:
+                        retry_code = int(m.group(1))
+                except Exception:
+                    retry_code = None
+                if retry_code in (401, 403):
+                    self.app._handle_auth_expired(
+                        f"Authentication expired while starting an action (HTTP {retry_code}). Please log in again."
+                    )
                     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,
-                            ),
-                        )
+                        w = getattr(self, "_streaming_widget_ref", None)
+                        if w:
+                            w.remove()
                     except Exception:
                         pass
+                    self._streaming_widget_ref = None
+                    self._set_streaming(False)
+                    return
 
             if not success:
                 self.add_message(f"Error starting action: {message}", "error")
@@ -2944,25 +3102,32 @@ class DashboardScreen(Screen):
                             code = None
 
                         if code in (401, 403):
-                            try:
-                                refreshed = bool(self.app._refresh_token_if_needed(force=True))
-                            except Exception:
-                                refreshed = False
+                            refreshed = self._refresh_auth_or_redirect(
+                                code,
+                                context="fetching the final action result",
+                            )
                             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
+                                if not success:
+                                    retry_code = None
+                                    try:
+                                        m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(message or ""))
+                                        if m:
+                                            retry_code = int(m.group(1))
+                                    except Exception:
+                                        retry_code = None
+                                    if retry_code in (401, 403):
+                                        auth_failed_code = retry_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",
+                self.app._handle_auth_expired(
+                    f"Authentication expired while fetching the result (HTTP {auth_failed_code}). Please log in again."
                 )
                 got_final_result = True
                 # Stop spinner/blink immediately when we have a terminal state.
@@ -3271,12 +3436,25 @@ class DashboardScreen(Screen):
             except Exception:
                 code = None
             if code in (401, 403):
-                try:
-                    refreshed = bool(self.app._refresh_token_if_needed(force=True))
-                except Exception:
-                    refreshed = False
+                refreshed = self._refresh_auth_or_redirect(
+                    code,
+                    context="refreshing displayed conversation history",
+                )
                 if refreshed:
                     success, result, msg = self.app.autobots_client.get_action_result(run_id)
+                    if (not success) and msg:
+                        retry_code = None
+                        try:
+                            m = re.search(r"(?:HTTP|status)\s*(\d{3})", str(msg))
+                            if m:
+                                retry_code = int(m.group(1))
+                        except Exception:
+                            retry_code = None
+                        if retry_code in (401, 403):
+                            self.app._handle_auth_expired(
+                                f"Authentication expired while refreshing displayed conversation history (HTTP {retry_code}). Please log in again."
+                            )
+                            return
         if not success or not result:
             return
         self._render_conversation_history_from_action_result(result)

{kiwi_code-0.0.41 → kiwi_code-0.0.43}/tests/test_tui_headless.py

@@ -701,7 +701,7 @@ async def test_tui_continue_run_updates_action_name_from_run(
 async def test_tui_autocode_select_shows_only_special_action_names(
     isolated_home: Path, monkeypatch: pytest.MonkeyPatch
  ) -> None:
-    """/autocode-select should open the picker with only the 3 special actions."""
+    """/autocode-select should open the picker with only the 4 special actions."""
     tokens_path = isolated_home / ".kiwi" / "tokens.json"
     tokens_path.parent.mkdir(parents=True, exist_ok=True)
     tokens_path.write_text(
@@ -720,6 +720,7 @@ async def test_tui_autocode_select_shows_only_special_action_names(
         "69c2180355a89324a9926bc6": "AutoCode Alpha",
         "6a0625b8ab5f80ba8ac5d012": "AutoCode Beta",
         "69e4be0d70c2d7a89197e66e": "AutoCode Gamma",
+        "6a1c0773c519da8a0fa9b8a4": "AutoCode Delta",
     }
 
     from kiwi_tui.screens.dashboard import DashboardScreen
@@ -753,10 +754,11 @@ async def test_tui_autocode_select_shows_only_special_action_names(
 
         assert type(app.screen).__name__ == "IdPickerScreen"
         table = app.screen.query_one("#idpicker-table", DataTable)
-        assert table.row_count == 3
+        assert table.row_count == 4
         assert list(table.get_row_at(0)) == ["1", "AutoCode Alpha"]
         assert list(table.get_row_at(1)) == ["2", "AutoCode Beta"]
         assert list(table.get_row_at(2)) == ["3", "AutoCode Gamma"]
+        assert list(table.get_row_at(3)) == ["4", "AutoCode Delta"]
 
 
 
@@ -853,8 +855,6 @@ async def test_tui_streaming_requests_autofollow_when_viewport_is_near_bottom(
         )
         await pilot.pause()
         assert calls == [{"after_refresh": True}]
-
-
 @pytest.mark.asyncio
 async def test_tui_streaming_does_not_force_scroll_when_user_reads_older_messages(
     isolated_home: Path,
@@ -881,45 +881,271 @@ async def test_tui_streaming_does_not_force_scroll_when_user_reads_older_message
         await pilot.pause()
         assert type(app.screen).__name__ == "DashboardScreen"
         screen = app.screen
-        messages = screen.query_one("#messages")
 
-        for i in range(30):
-            screen.add_message(
-                "\n".join(f"history {i} line {j}" for j in range(4)),
-                "assistant",
+        calls: list[dict] = []
+        monkeypatch = pytest.MonkeyPatch()
+        monkeypatch.setattr(screen, "_messages_is_near_bottom", lambda *args, **kwargs: False)
+        monkeypatch.setattr(
+            screen,
+            "_scroll_messages_to_end",
+            lambda *args, **kwargs: calls.append(dict(kwargs)),
+        )
+        try:
+            widget = screen.update_streaming_message({"blocks": [{"text": "stream start"}]})
+            await pilot.pause()
+            assert widget is not None
+            assert calls == []
+
+            screen.update_streaming_message(
+                {"blocks": [{"text": "\n".join(f"stream line {i}" for i in range(60))}]},
+                widget,
             )
+            await pilot.pause()
+            assert calls == []
+        finally:
+            monkeypatch.undo()
+
+@pytest.mark.asyncio
+async def test_tui_quits_cleanly(isolated_home: Path) -> None:
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
         await pilot.pause()
-        assert messages.max_scroll_y > 0
+        await pilot.press("ctrl+c")
+        await pilot.pause()
+    # Reaching here without an exception is the assertion.
 
-        widget = screen.update_streaming_message({"blocks": [{"text": "stream start"}]})
+
+@pytest.mark.asyncio
+async def test_tui_redirects_to_login_when_auth_expires(isolated_home: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
         await pilot.pause()
-        assert widget is not None
+        assert type(app.screen).__name__ == "DashboardScreen"
 
-        target_y = max(0, int(messages.max_scroll_y) - 5)
-        messages.scroll_to(y=target_y, animate=False, immediate=True)
+        app._handle_auth_expired("Session expired during test.")
         await pilot.pause()
-        y_before = int(messages.scroll_offset.y)
-        target_before = int(messages.scroll_target_y)
-        assert y_before == target_before
-        assert y_before < int(messages.max_scroll_y)
 
-        screen.update_streaming_message(
-            {"blocks": [{"text": "\n".join(f"stream line {i}" for i in range(60))}]},
-            widget,
+        assert type(app.screen).__name__ == "LoginScreen"
+        assert not tokens_path.exists()
+
+
+@pytest.mark.asyncio
+async def test_tui_run_action_403_redirects_to_login_when_refresh_cannot_run(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        screen = app.screen
+
+        monkeypatch.setattr(app, "_refresh_token_if_needed", lambda force=False: False)
+        monkeypatch.setattr(
+            app.autobots_client,
+            "run_action_async",
+            lambda *args, **kwargs: (False, None, "Failed to start action: status 403"),
         )
+
+        screen.run_action_with_polling("hello")
+        await pilot.pause(0.3)
+        await pilot.pause(0.3)
+
+        assert type(app.screen).__name__ == "LoginScreen"
+        assert not tokens_path.exists()
+
+
+@pytest.mark.asyncio
+async def test_tui_run_action_403_redirects_to_login_on_second_failure(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
         await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        screen = app.screen
+
+        monkeypatch.setattr(app, "_refresh_token_if_needed", lambda force=False: True)
+        monkeypatch.setattr(
+            app.autobots_client,
+            "run_action_async",
+            lambda *args, **kwargs: (False, None, "Failed to start action: status 403"),
+        )
+
+        screen.run_action_with_polling("hello")
+        await pilot.pause(0.3)
+        await pilot.pause(0.3)
+
+        assert type(app.screen).__name__ == "LoginScreen"
+        assert not tokens_path.exists()
+
+
+def test_tui_force_refresh_uses_refresh_token_even_when_access_token_not_expired(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": "2999-01-01T00:00:00",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from kiwi_cli.models import AuthTokens
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+
+    calls: list[str] = []
+
+    def _fake_refresh(refresh_token: str):
+        calls.append(refresh_token)
+        return True, AuthTokens(
+            access_token="new-access-token",
+            refresh_token="new-refresh-token",
+            token_type="Bearer",
+            expires_at=None,
+        ), "ok"
+
+    monkeypatch.setattr(app.autobots_client, "refresh_token", _fake_refresh)
+
+    assert app._refresh_token_if_needed(force=True) is True
+    assert calls == ["test-refresh-token"]
 
-        assert int(messages.scroll_offset.y) == y_before
-        assert int(messages.scroll_target_y) == target_before
-        assert int(messages.scroll_offset.y) < int(messages.max_scroll_y)
 
 @pytest.mark.asyncio
-async def test_tui_quits_cleanly(isolated_home: Path) -> None:
+async def test_tui_auth_expired_clears_dashboard_draft_and_messages(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from textual.containers import VerticalScroll
     from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
 
     app = AutobotsTUI()
     async with app.run_test() as pilot:
         await pilot.pause()
-        await pilot.press("ctrl+c")
+        assert type(app.screen).__name__ == "DashboardScreen"
+        dashboard = app.screen
+        chat_input = dashboard.query_one("#chat-input", ChatInput)
+        messages = dashboard.query_one("#messages", VerticalScroll)
+
+        chat_input.value = "hi"
+        dashboard.add_message("hi", "user")
         await pilot.pause()
-    # Reaching here without an exception is the assertion.
+        assert len(list(messages.children)) > 0
+
+        app._handle_auth_expired("Session expired during test.")
+        await pilot.pause()
+
+        assert chat_input.value == ""
+        assert len(list(messages.children)) == 0
+        assert type(app.screen).__name__ == "LoginScreen"

{kiwi_code-0.0.41 → kiwi_code-0.0.43}/uv.lock

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