kiwi-code 0.0.36__tar.gz → 0.0.37__tar.gz

{kiwi_code-0.0.36 → kiwi_code-0.0.37}/PKG-INFO

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

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

@@ -117,25 +117,26 @@ class TokenManager:
             return None
 
     def clear_tokens(self) -> None:
-        """Clear stored tokens."""
-        self._tokens = None
+        """Clear stored tokens under the same lock used for refresh/write flows."""
+        with self.file_lock():
+            self._tokens = None
 
-        if self.token_path.exists():
-            try:
-                self.token_path.unlink()
-                logger.info("Authentication tokens cleared")
-            except Exception as e:
-                logger.error(f"Failed to clear tokens: {e}")
+            if self.token_path.exists():
+                try:
+                    self.token_path.unlink()
+                    logger.info("Authentication tokens cleared")
+                except Exception as e:
+                    logger.error(f"Failed to clear tokens: {e}")
 
     @property
     def tokens(self) -> Optional[AuthTokens]:
-        """Get current tokens.
+        """Get current tokens from disk.
 
-        Returns:
-            Current AuthTokens or None
+        In multiprocess mode the shared token file may change at any time, so
+        callers should observe the latest on-disk state rather than a long-lived
+        in-memory cache.
         """
-        if self._tokens is None:
-            self._tokens = self.load_tokens()
+        self._tokens = self.load_tokens()
         return self._tokens
 
     def is_authenticated(self) -> bool:

{kiwi_code-0.0.36 → kiwi_code-0.0.37}/src/kiwi_cli/cli.py

@@ -82,13 +82,16 @@ def _force_refresh_tokens(tm: TokenManager) -> bool:
         tokens = tm.load_tokens()
         if not tokens:
             return False
+        access = getattr(tokens, "access_token", None)
+        if access and not tokens.is_expired():
+            return True
         refresh = getattr(tokens, "refresh_token", None)
         if not refresh:
             return False
 
         wrapper = AutobotsClientWrapper(
             base_url=_backend_url(),
-            access_token=getattr(tokens, "access_token", None),
+            access_token=access,
         )
         ok, new_tokens, _msg = wrapper.refresh_token(str(refresh))
         if ok and new_tokens:

{kiwi_code-0.0.36 → kiwi_code-0.0.37}/src/kiwi_cli/client.py

@@ -183,8 +183,9 @@ 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:
-                # Best-effort: send the (possibly expired) access token for anomaly tracking.
-                # The backend refresh endpoint must not *require* it.
+                # Send the current access token alongside the refresh token.
+                # In multi-process setups callers must ensure this wrapper has been
+                # synchronized with the latest on-disk access token before refresh.
                 headers: dict[str, str] = {}
                 if self.access_token:
                     headers["Authorization"] = f"Bearer {self.access_token}"

{kiwi_code-0.0.36 → kiwi_code-0.0.37}/src/kiwi_runtime/main.py

@@ -175,12 +175,19 @@ class _TokensLock:
             self.fp = None
 
 
-async def _refresh_tokens(http_base_url: str, refresh_token: str) -> dict[str, Any]:
+async def _refresh_tokens(
+    http_base_url: str, refresh_token: str, access_token: str | None = None
+ ) -> dict[str, Any]:
     """Refresh tokens via the backend and return tokens.json-compatible dict."""
     from datetime import datetime, timedelta
     url = f"{http_base_url.rstrip('/')}/v1/auth/session/refresh"
+    headers: dict[str, str] = {}
+    if access_token:
+        headers["Authorization"] = f"Bearer {access_token}"
     async with httpx.AsyncClient(timeout=30) as client:
-        resp = await client.post(url, params={"refresh_token": refresh_token})
+        resp = await client.post(
+            url, params={"refresh_token": refresh_token}, headers=headers
+        )
     if resp.status_code != 200:
         raise Exception(f"Token refresh failed (HTTP {resp.status_code}): {resp.text[:200]}")
     body = resp.json()
@@ -206,7 +213,6 @@ async def _refresh_tokens(http_base_url: str, refresh_token: str) -> dict[str, A
         out["expires_at"] = expires_at
     return out
 
-
 async def _get_valid_access_token(http_base_url: str, fallback_token: str) -> str:
     """Return a non-expired access token, preferring ~/.kiwi/tokens.json when available.
 
@@ -235,7 +241,9 @@ async def _get_valid_access_token(http_base_url: str, fallback_token: str) -> st
             return access2
         # Still expired -> attempt refresh. If refresh fails, fall back to the best token we have.
         try:
-            new_data = await _refresh_tokens(http_base_url, refresh2)
+            new_data = await _refresh_tokens(
+                http_base_url, str(refresh2), str(access2) if access2 else None
+            )
             _atomic_write_tokens(TOKENS_PATH, new_data)
             return str(new_data.get("access_token"))
         except Exception:
@@ -253,6 +261,23 @@ async def _force_refresh_access_token(http_base_url: str) -> dict[str, Any] | No
     data = _load_tokens_file(TOKENS_PATH) or {}
     with _TokensLock():
         data2 = _load_tokens_file(TOKENS_PATH) or data or {}
+        access_token = data2.get("access_token")
+        expires_at = _parse_expires_at(data2.get("expires_at"))
+        if access_token and not _token_is_expired(access_token=str(access_token), expires_at=expires_at):
+            return data2
+        refresh_token = data2.get("refresh_token")
+        if not refresh_token:
+            return None
+        try:
+            new_data = await _refresh_tokens(
+                http_base_url, str(refresh_token), str(access_token) if access_token else None
+            )
+            _atomic_write_tokens(TOKENS_PATH, new_data)
+            return new_data
+        except Exception:
+            # If refresh failed, keep existing auth state and let the caller decide.
+            return None
+        data2 = _load_tokens_file(TOKENS_PATH) or data or {}
         refresh_token = data2.get("refresh_token")
         if not refresh_token:
             return None

{kiwi_code-0.0.36 → kiwi_code-0.0.37}/src/kiwi_tui/main.py

@@ -167,6 +167,7 @@ class AutobotsTUI(App):
         self.pending_runtime_id: str | None = None
 
         self._kiwi_token = None  # Set after auth for kiwi CLI session
+        self._token_refresh_timer = None  # Periodic token refresh handle
         # self._kiwi_pid = None  # PID of the runtime process
         # self._log_fp = None  # File pointer for tailing runtime log
         self._kiwi_log_lines = collections.deque(maxlen=self._KIWI_LOG_BUFFER_SIZE)
@@ -179,11 +180,14 @@ class AutobotsTUI(App):
         with self.token_manager.file_lock():
             tokens = self.token_manager.load_tokens()
             if tokens:
-                # Check if token needs refresh
                 if tokens.is_expired():
                     logger.info("Access token expired, attempting refresh")
-                    # Try to refresh token
-                    temp_client = AutobotsClientWrapper(base_url=self.config.backend_url)
+                    # Try to refresh token using the latest access token loaded
+                    # from disk, not stale in-memory client state.
+                    temp_client = AutobotsClientWrapper(
+                        base_url=self.config.backend_url,
+                        access_token=tokens.access_token,
+                    )
                     success, new_tokens, message = temp_client.refresh_token(tokens.refresh_token)
 
                     if success and new_tokens:
@@ -578,16 +582,19 @@ class AutobotsTUI(App):
     #     self._kiwi_pid = None
     #     self._close_log_tail()
     #     self._kiwi_log_lines.append("--- Runtime disconnected ---")
-
-    # ------------------------------------------------------------------
-    # Periodic token refresh
-    # ------------------------------------------------------------------
-
     def _start_token_refresh(self) -> None:
         """Schedule periodic token refresh (every `refresh_interval` minutes)."""
         interval_min = self.config.refresh_interval  # default 5
         logger.info(f"Token refresh scheduled every {interval_min} minutes")
-        self.set_interval(interval_min * 60, self._refresh_token_if_needed)
+        existing_timer = getattr(self, "_token_refresh_timer", None)
+        if existing_timer is not None:
+            try:
+                existing_timer.stop()
+            except Exception:
+                pass
+        self._token_refresh_timer = self.set_interval(
+            interval_min * 60, self._refresh_token_if_needed
+        )
         # Write current tokens to shared files so runtime can read them
         # if self._kiwi_token:
         #     runtime_manager.save_token(self._kiwi_token)
@@ -596,10 +603,11 @@ class AutobotsTUI(App):
         #     runtime_manager.save_refresh_token(tokens.refresh_token)
 
     def _refresh_token_if_needed(self, force: bool = False) -> bool:
-        """Check token expiry and refresh if needed.
+        """Synchronize auth state from disk and refresh only when needed.
 
         Args:
-            force: If True, attempt refresh even if the token doesn't look expired.
+            force: If True, re-check disk state immediately and refresh only if
+                the shared on-disk access token is still expired.
         """
         with self.token_manager.file_lock():
             tokens = self.token_manager.load_tokens()
@@ -607,14 +615,21 @@ class AutobotsTUI(App):
                 logger.debug("No tokens to refresh")
                 return False
 
-            if (not force) and (not tokens.is_expired()):
-                logger.debug("Token still valid, skipping refresh")
+            if 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)
+                    self._kiwi_token = tokens.access_token
                 return True
 
             if not getattr(tokens, "refresh_token", None):
                 logger.warning("No refresh token available; cannot refresh access token")
                 return False
 
+            if getattr(tokens, "access_token", None):
+                self.autobots_client.update_token(tokens.access_token)
+                self._kiwi_token = tokens.access_token
+
             logger.info("Refreshing access token...")
             success, new_tokens, message = self.autobots_client.refresh_token(tokens.refresh_token)
 
@@ -652,26 +667,6 @@ class AutobotsTUI(App):
     #     if self._kiwi_pid:
     #         self._stop_runtime()
     #         logger.info("Runtime stopped for restart")
-    #     self._start_kiwi_session()
-    #     if self._kiwi_pid:
-    #         logger.info("Runtime restarted by user")
-    #         self.notify("Runtime restarted", severity="information")
-    #     else:
-    #         self.notify("Failed to restart runtime", severity="error")
-
-    # def action_runtime_logs(self) -> None:
-    #     """Show the runtime log stream."""
-    #     self.push_screen("runtime_logs")
-
-    def action_toggle_dark(self) -> None:
-        """Toggle dark mode."""
-        self.dark = not self.dark
-        theme = "dark" if self.dark else "light"
-        # Runtime-only: do not persist theme to disk.
-        self.config.theme = theme
-        logger.info(f"Theme changed to {theme}")
-        self.notify(f"Theme: {theme}", severity="information")
-
     def action_show_logs(self) -> None:
         """Global keyboard shortcut to open CLI logs (if dashboard is active)."""
         try:
@@ -689,8 +684,17 @@ class AutobotsTUI(App):
         # self._close_log_tail()
         # self._kiwi_pid = None
 
+        timer = getattr(self, "_token_refresh_timer", None)
+        if timer is not None:
+            try:
+                timer.stop()
+            except Exception:
+                pass
+            self._token_refresh_timer = None
+
         # Clear tokens
         self.token_manager.clear_tokens()
+        self._kiwi_token = None
 
         # Reset client to unauthenticated
         self.autobots_client = AutobotsClientWrapper(
@@ -766,6 +770,43 @@ class AutobotsTUI(App):
     def action_quit(self) -> None:
         """Quit the application."""
         self.request_quit()
+        try:
+            all_rt = list_known_runtimes()
+        except Exception:
+            all_rt = []
+
+        alive = [r for r in all_rt if r.get("alive") and r.get("pid")]
+        if not alive:
+            self._final_exit()
+            return
+
+        rows: list[RuntimeRow] = []
+        for r in alive:
+            try:
+                meta = r.get("meta") or {}
+                name = None
+                if isinstance(meta, dict):
+                    name = meta.get("run_name")
+                rows.append(
+                    RuntimeRow(
+                        kind=str(r.get("kind")),
+                        runtime_id=str(r.get("id")),
+                        pid=int(r.get("pid")),
+                        alive=True,
+                        log_path=str(r.get("log_path")),
+                        name=name if isinstance(name, str) else None,
+                        kill=False,
+                    )
+                )
+            except Exception:
+                continue
+
+        # Show interactive prompt; the callback will exit.
+        self.push_screen(RuntimeCleanupScreen(rows), callback=self._on_runtime_cleanup_done)
+
+    def action_quit(self) -> None:
+        """Quit the application."""
+        self.request_quit()
 
 
 def _run_tui(runtime_args: RuntimeConnectArgs | None = None):

{kiwi_code-0.0.36 → kiwi_code-0.0.37}/uv.lock

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