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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.35"
+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.35 → 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.35 → 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.35 → 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.35 → 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.35 → 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.35 → kiwi_code-0.0.37}/src/kiwi_tui/widgets.py

@@ -2,6 +2,7 @@
 
 import shlex
 import sys
+import time
 from pathlib import Path
 from urllib.parse import unquote, urlparse
 
@@ -94,6 +95,11 @@ class ChatInput(TextArea):
         self._history_index: int = -1
         self._draft: str = ""  # saves current text when browsing history
         self.picker_active: bool = False  # True when inline file picker is showing
+        self._pending_clipboard_paste: str | None = None
+        self._recent_paste_text: str = ""
+        self._recent_paste_at: float = 0.0
+        self._last_value_snapshot: str = self.text
+        self._normalizing_duplicate_paste: bool = False
 
         # Ensure a sensible initial height. This will be refined after the first layout.
         self._adjust_height()
@@ -160,16 +166,69 @@ class ChatInput(TextArea):
                     resolved_paths = []
                     break
                 path = Path(normalized_token).expanduser()
-                if not path.exists() or not path.is_file():
+                try:
+                    if not path.exists() or not path.is_file():
+                        resolved_paths = []
+                        break
+                    resolved_paths.append(str(path.resolve()))
+                except OSError:
                     resolved_paths = []
                     break
-                resolved_paths.append(str(path.resolve()))
             if resolved_paths:
                 # Preserve order while removing duplicates.
                 return list(dict.fromkeys(resolved_paths))
 
         return None
 
+    def _remember_recent_paste(self, text: str) -> None:
+        """Remember the latest paste payload to avoid duplicate insertions."""
+        if not text:
+            return
+        self._recent_paste_text = text
+        self._recent_paste_at = time.monotonic()
+
+    def _is_recent_duplicate_paste(self, text: str, *, window_sec: float = 0.25) -> bool:
+        """Return True when the same paste payload was just handled."""
+        if not text:
+            return False
+
+    def _flush_pending_clipboard_paste(self, expected_text: str) -> None:
+        """Insert a deferred clipboard paste if no terminal paste event arrived."""
+        if self.read_only:
+            self._pending_clipboard_paste = None
+            return
+        if self._pending_clipboard_paste != expected_text:
+            return
+        self._pending_clipboard_paste = None
+        if result := self._replace_via_keyboard(expected_text, *self.selection):
+            self.move_cursor(result.end_location)
+            self.focus()
+
+    def _collapse_duplicate_append(self, previous: str, current: str) -> str | None:
+        """Collapse accidental duplicate text appended to the end of the input.
+
+        Some terminals appear to deliver a single paste twice. In the observed
+        failure mode, the duplicated text is appended contiguously at the cursor
+        position, so the new value becomes `previous + chunk + chunk`.
+        """
+        if current == previous:
+            return None
+        if not current.startswith(previous):
+            return None
+        tail = current[len(previous):]
+        if not tail or len(tail) % 2 != 0:
+            return None
+        half = len(tail) // 2
+        if half < 3:
+            return None
+        left = tail[:half]
+        right = tail[half:]
+        if left != right:
+            return None
+        # Avoid collapsing legitimately long repeated-character pastes.
+        if len(set(left)) == 1:
+            return None
+        return previous + left
     def _move_cursor_to_end(self) -> None:
         try:
             self.move_cursor(self.document.end)
@@ -218,6 +277,22 @@ class ChatInput(TextArea):
 
     def on_text_area_changed(self, event: TextArea.Changed) -> None:
         # Keep height in sync with content changes.
+        if self._normalizing_duplicate_paste:
+            self._last_value_snapshot = self.value
+            self._adjust_height()
+            return
+
+        previous = self._last_value_snapshot
+        current = self.value
+        collapsed = self._collapse_duplicate_append(previous, current)
+        if collapsed is not None:
+            self._normalizing_duplicate_paste = True
+            try:
+                self.value = collapsed
+                current = collapsed
+            finally:
+                self._normalizing_duplicate_paste = False
+        self._last_value_snapshot = current
         self._adjust_height()
 
     def update_suggestion(self) -> None:
@@ -357,8 +432,16 @@ class ChatInput(TextArea):
         if self.disabled or self.read_only:
             return
 
+        if self._pending_clipboard_paste == event.text:
+            self._pending_clipboard_paste = None
+        elif self._is_recent_duplicate_paste(event.text):
+            event.prevent_default()
+            event.stop()
+            return
+
         file_paths = self._extract_pasted_file_paths(event.text)
         if file_paths:
+            self._remember_recent_paste(event.text)
             event.prevent_default()
             event.stop()
             self.post_message(self.FilePathsPasted(file_paths))
@@ -366,6 +449,17 @@ class ChatInput(TextArea):
             return
 
         await super()._on_paste(event)
+        self._remember_recent_paste(event.text)
+
+    def action_paste(self) -> None:
+        """Rely on terminal/native paste delivery to avoid duplicate textbox inserts.
+
+        In some terminals, invoking the widget paste action and receiving a terminal
+        paste event both happen for a single user paste gesture, which duplicates the
+        inserted text. We therefore make the explicit TextArea paste action a no-op
+        and let the terminal-delivered `Paste` event be the single source of truth.
+        """
+        return
 
 class StatusBadge(Static):
     """A colored status badge widget."""

{kiwi_code-0.0.35 → kiwi_code-0.0.37}/tests/test_tui_headless.py

@@ -199,6 +199,146 @@ async def test_tui_drag_drop_paste_uploads_file_paths(
         assert chat_input.value == ""
         assert screen._pending_urls == ["https://example.com/uploaded/drag-file.txt"]
 
+@pytest.mark.asyncio
+async def test_tui_chat_input_dedupes_clipboard_paste_echo(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A local clipboard paste followed by a terminal paste event should insert once."""
+    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 import events
+    from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
+
+    app = AutobotsTUI()
+    app._clipboard = "run-123"  # type: ignore[attr-defined]
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        chat_input = app.screen.query_one("#chat-input", ChatInput)
+
+        chat_input.action_paste()
+        await chat_input._on_paste(events.Paste("run-123"))
+        await pilot.pause()
+
+        assert chat_input.value == "run-123"
+
+@pytest.mark.asyncio
+async def test_tui_long_text_paste_is_not_treated_as_file_path(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Long pasted text should not crash path detection and should remain normal text."""
+    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 import events
+    from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        chat_input = app.screen.query_one("#chat-input", ChatInput)
+
+        long_text = "A" * 5000
+        await chat_input._on_paste(events.Paste(long_text))
+        await pilot.pause()
+
+        assert chat_input.value == long_text
+
+
+@pytest.mark.asyncio
+async def test_tui_chat_input_collapses_duplicate_pasted_text(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """If the terminal inserts the same pasted text twice, collapse it back to one copy."""
+    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
+    from kiwi_tui.widgets import ChatInput
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        chat_input = app.screen.query_one("#chat-input", ChatInput)
+
+        duplicated = "Action: AutoCodeAction: AutoCode"
+        chat_input.value = duplicated
+        chat_input.on_text_area_changed(ChatInput.Changed(chat_input))
+        await pilot.pause()
+
+        assert chat_input.value == "Action: AutoCode"
+
+
+
+
 @pytest.mark.asyncio
 async def test_tui_screen_level_paste_uploads_file_paths(
     isolated_home: Path, monkeypatch: pytest.MonkeyPatch

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

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