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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.41"
+version = "0.0.42"
 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.42}/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.42}/src/kiwi_tui/screens/dashboard.py

@@ -600,6 +600,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 +635,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 +1287,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 +1348,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 +1364,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 +1421,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 +1435,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 +1495,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 +1511,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 +1558,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 +1572,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 +1632,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 +1648,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 +1742,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 +2351,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 +2694,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 +2903,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 +3101,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 +3435,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.42}/uv.lock

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