kiwi-code 0.0.434__tar.gz → 0.0.436__tar.gz

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.434"
+version = "0.0.436"
 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.434 → kiwi_code-0.0.436}/src/kiwi_cli/auth.py

@@ -6,6 +6,9 @@ import time
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Optional
+from loguru import logger
+from .models import AuthTokens
+
 def _lock_path_for(token_path: Path) -> Path:
     return token_path.with_suffix(".lock")
 
@@ -51,11 +54,6 @@ def _atomic_write_json(path: Path, data: dict) -> None:
     if sys.platform != "win32":
         path.chmod(0o600)
 
-from loguru import logger
-
-from .models import AuthTokens
-
-
 
 class TokenManager:
     """Manages authentication tokens with secure storage."""
@@ -102,17 +100,25 @@ class TokenManager:
             logger.debug("No saved tokens found")
             return None
 
-        try:
-            with open(self.token_path, "r") as f:
-                data = json.load(f)
-
-            self._tokens = AuthTokens(**data)
-            logger.info("Authentication tokens loaded")
-            return self._tokens
-        except Exception as e:
-            logger.error(f"Failed to load tokens: {e}")
-            return None
-
+        last_err: Exception | None = None
+        for attempt in range(5):
+            try:
+                with open(self.token_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                self._tokens = AuthTokens(**data)
+                logger.info("Authentication tokens loaded")
+                return self._tokens
+            except Exception as e:
+                last_err = e
+                if attempt < 4:
+                    time.sleep(0.05)
+                    continue
+                logger.error(f"Failed to load tokens: {e}")
+                return None
+        if last_err:
+            logger.error(f"Failed to load tokens: {last_err}")
+        return None
+    
     def clear_tokens(self) -> None:
         """Clear stored tokens under the same lock used for refresh/write flows."""
         with self.file_lock():

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/src/kiwi_cli/client.py

@@ -71,7 +71,7 @@ class AutobotsClientWrapper:
         self.access_token = access_token
         self.client = AuthenticatedClient(
             base_url=self.base_url,
-            token=access_token,
+            token=self.access_token,
             raise_on_unexpected_status=False,
         )
         logger.info("Client updated with new access token")
@@ -598,6 +598,17 @@ class AutobotsClientWrapper:
                             logger.error(f"Error processing SSE data: {e}")
                         return False
 
+                    pending_blank = False
+
+                    def _is_field_line(s: str) -> bool:
+                        return (
+                            s.startswith("data:")
+                            or s.startswith(":")
+                            or s.startswith("event:")
+                            or s.startswith("id:")
+                            or s.startswith("retry:")
+                        )
+
                     async for chunk in response.aiter_bytes():
                         text_chunk = decoder.decode(chunk, final=False)
                         buffer += text_chunk
@@ -606,14 +617,26 @@ class AutobotsClientWrapper:
                             line, buffer = buffer.split("\n", 1)
                             line = line.rstrip("\r")
 
-                            # SSE event boundary (blank line)
+                            if pending_blank:
+                                if line == "":
+                                    pending_blank = False
+                                    if _flush_event():
+                                        return
+                                    continue
+                                if _is_field_line(line):
+                                    pending_blank = False
+                                    if _flush_event():
+                                        return
+                                else:
+                                    event_data_lines.append("")
+                                    pending_blank = False
+
                             if line == "":
-                                if _flush_event():
-                                    return
+                                if event_data_lines:
+                                    pending_blank = True
                                 continue
 
                             if line.startswith(":"):
-                                # keep-alive comments
                                 continue
 
                             if line.startswith("data:"):
@@ -626,7 +649,6 @@ class AutobotsClientWrapper:
                             if event_data_lines:
                                 event_data_lines.append(line)
 
-                    # Flush any remaining bytes in decoder + any pending event data.
                     decoder.decode(b"", final=True)
                     _flush_event()
         except Exception as e:

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/src/kiwi_cli/models.py

@@ -65,14 +65,7 @@ class AuthTokens(BaseModel):
     token_type: str = "Bearer"
     expires_at: Optional[datetime] = None
 
-    def is_expired(self) -> bool:
-        """Check if access token is expired.
-
-        Notes:
-        - Prefer `expires_at` when present.
-        - If `expires_at` is missing (common when the backend doesn't return expires_in),
-          fall back to the JWT `exp` claim (if the access token is a JWT).
-        """
+    def effective_expires_at(self) -> datetime | None:
         def _jwt_exp(token: str) -> datetime | None:
             try:
                 parts = token.split(".")
@@ -93,16 +86,26 @@ class AuthTokens(BaseModel):
         jwt_expires_at = _jwt_exp(self.access_token)
         effective_expires_at = self.expires_at or jwt_expires_at
         if self.expires_at and jwt_expires_at:
-            # Be conservative if they disagree.
             effective_expires_at = min(self.expires_at, jwt_expires_at)
+        return effective_expires_at
 
-        if not effective_expires_at:
-            # No expiry info; assume valid (server will decide).
+    def is_expiring_within(self, seconds: int) -> bool:
+        exp = self.effective_expires_at()
+        if not exp:
+            return False
+        try:
+            return datetime.now() >= (exp - timedelta(seconds=max(0, int(seconds))))
+        except Exception:
             return False
 
+    def is_expired(self) -> bool:
+        """Check if access token is expired (with a small safety buffer)."""
+        exp = self.effective_expires_at()
+        if not exp:
+            # No expiry info; assume valid (server will decide).
+            return False
         # Add 60 second buffer before expiry
-        return datetime.now() >= (effective_expires_at - timedelta(seconds=60))
-
+        return datetime.now() >= (exp - timedelta(seconds=60))
 
 class LoginCredentials(BaseModel):
     """Login credentials."""

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/src/kiwi_tui/main.py

@@ -602,6 +602,11 @@ class AutobotsTUI(App):
         self._token_refresh_timer = self.set_interval(
             interval_min * 60, self._refresh_token_if_needed
         )
+        try:
+            self._refresh_token_if_needed(force=False)
+        except Exception:
+            pass
+
         # Write current tokens to shared files so runtime can read them
         # if self._kiwi_token:
         #     runtime_manager.save_token(self._kiwi_token)
@@ -609,6 +614,38 @@ class AutobotsTUI(App):
         # if tokens and tokens.refresh_token:
         #     runtime_manager.save_refresh_token(tokens.refresh_token)
 
+    def _sync_autobots_client_from_disk(self) -> bool:
+        try:
+            with self.token_manager.file_lock():
+                tokens = self.token_manager.load_tokens()
+        except Exception:
+            tokens = None
+        access = getattr(tokens, "access_token", None) if tokens else None
+        try:
+            access_str = str(access)
+            log_full = os.environ.get("KIWI_LOG_TOKENS") == "1"
+            if log_full:
+                logger.debug(f"Loaded access token from disk: {access_str}")
+            else:
+                redacted = access_str
+                if len(access_str) > 24:
+                    redacted = f"{access_str[:12]}...{access_str[-6:]}"
+                logger.debug(
+                    f"Loaded access token from disk: {redacted} (len={len(access_str)})"
+                )
+        except Exception:
+            # Best-effort only; never block requests on logging.
+            pass
+
+        if not access:
+            return False
+        try:
+            self.autobots_client.update_token(str(access))
+            return True
+        except Exception:
+            return False
+
+
     def _refresh_token_if_needed(self, force: bool = False) -> bool:
         """Synchronize auth state from disk and refresh when needed.
 
@@ -623,7 +660,28 @@ class AutobotsTUI(App):
                 logger.debug("No tokens to refresh")
                 return False
 
-            if not force and not tokens.is_expired():
+            expired = False
+            try:
+                expired = bool(tokens.is_expired())
+            except Exception:
+                expired = False
+
+            threshold_sec = 60
+            try:
+                threshold_sec = max(60, int(self.config.refresh_interval) * 60 + 120)
+            except Exception:
+                threshold_sec = 360
+
+            expiring_soon = False
+            try:
+                fn = getattr(tokens, "is_expiring_within", None)
+                expiring_soon = bool(fn and fn(threshold_sec))
+            except Exception:
+                expiring_soon = False
+
+            needs_refresh = bool(force or expired or expiring_soon)
+
+            if not needs_refresh:
                 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)
@@ -631,8 +689,19 @@ class AutobotsTUI(App):
                 return True
 
             if not getattr(tokens, "refresh_token", None):
-                logger.warning("No refresh token available; cannot refresh access token")
-                return False
+                if force or expired:
+                    logger.warning("No refresh token available; cannot refresh access token")
+                    return False
+                logger.warning(
+                    f"Access token expires within {threshold_sec}s but no refresh token; continuing with existing token"
+                )
+                if getattr(tokens, "access_token", None):
+                    self.autobots_client.update_token(tokens.access_token)
+                    self._kiwi_token = tokens.access_token
+                return True
+
+            if expiring_soon and not expired and not force:
+                logger.info(f"Access token expires within {threshold_sec}s; refreshing early")
 
             if getattr(tokens, "access_token", None):
                 self.autobots_client.update_token(tokens.access_token)

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/src/kiwi_tui/screens/dashboard.py

@@ -627,6 +627,11 @@ class DashboardScreen(Screen):
         from autobots_client.api.actions import get_action_v1_actions_id_get
 
         requested_action_id = self.current_action_id
+        try:
+            self.app._sync_autobots_client_from_disk()
+        except Exception:
+            pass
+
         api_client = getattr(getattr(self.app, "autobots_client", None), "client", None)
         if api_client is None:
             return
@@ -855,6 +860,10 @@ class DashboardScreen(Screen):
         so the Textual UI stays responsive and can render the loading indicator.
         """
         try:
+            try:
+                self.app._sync_autobots_client_from_disk()
+            except Exception:
+                pass
             parts = command.strip().split()
             if not parts:
                 return
@@ -1821,6 +1830,11 @@ class DashboardScreen(Screen):
             self.add_message("Error: Client not initialized", "error")
             return None
 
+        try:
+            self.app._sync_autobots_client_from_disk()
+        except Exception:
+            pass
+
         api_client = self.app.autobots_client.client
         if not isinstance(api_client, AuthenticatedClient):
             self.add_message("Error: Not authenticated", "error")
@@ -1834,6 +1848,11 @@ class DashboardScreen(Screen):
     def _get_api_client_for_command(self, title: str):
         """Get API client for slash commands without writing errors into chat."""
         from autobots_client import AuthenticatedClient
+        try:
+            self.app._sync_autobots_client_from_disk()
+        except Exception:
+            pass
+
 
         if not hasattr(self.app, 'autobots_client'):
             self._show_command_result(title, "Error: Client not initialized", is_error=True)
@@ -3214,7 +3233,11 @@ class DashboardScreen(Screen):
                 pass
 
     async def _run_action_worker(self, user_input: str) -> None:
-        """Async worker: send the action request then stream results."""
+        try:
+            self.app._sync_autobots_client_from_disk()
+        except Exception:
+            pass
+
         client = self.app.autobots_client
 
         checkpoint_run_dir: Path | None = None
@@ -3402,6 +3425,11 @@ class DashboardScreen(Screen):
 
     async def _cache_run_name_worker(self, run_id: str) -> None:
         """Best-effort: cache the run's name in ~/.kiwi/runtimes so the quit prompt can show it."""
+        try:
+            self.app._sync_autobots_client_from_disk()
+        except Exception:
+            pass
+
         try:
             wrapper = self.app.autobots_client
         except Exception:
@@ -3449,6 +3477,11 @@ class DashboardScreen(Screen):
         Runs SSE streaming and result-polling concurrently.  Whichever
         detects a terminal state first (success *or* error) wins.
         """
+        try:
+            self.app._sync_autobots_client_from_disk()
+        except Exception:
+            pass
+
         client = self.app.autobots_client
         got_final_result = False
 

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/src/kiwi_tui/screens/runtime_cleanup.py

@@ -244,6 +244,11 @@ class RuntimeCleanupScreen(ModalScreen[list[int]]):
             if not by_run:
                 return
 
+            try:
+                self.app._sync_autobots_client_from_disk()
+            except Exception:
+                pass
+
             wrapper = getattr(self.app, "autobots_client", None)
             if not wrapper:
                 return

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/tests/test_tui_headless.py

@@ -852,55 +852,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,
- ) -> None:
-    """Streaming updates should not yank the viewport back to the bottom."""
-    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 kiwi_tui.main import AutobotsTUI
-
-    app = AutobotsTUI()
-    async with app.run_test(size=(80, 24)) as pilot:
-        await pilot.pause()
-        assert type(app.screen).__name__ == "DashboardScreen"
-        screen = app.screen
-
-        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:

{kiwi_code-0.0.434 → kiwi_code-0.0.436}/uv.lock

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