kiwi-code 0.0.18__tar.gz → 0.0.20__tar.gz

{kiwi_code-0.0.18 → kiwi_code-0.0.20}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.18"
+version = "0.0.20"
 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.18 → kiwi_code-0.0.20}/src/kiwi_runtime/main.py

@@ -1039,9 +1039,66 @@ def _render_block_text(text: str) -> list[str]:
     return rows
 
 
+
+def _stdout_encoding() -> str:
+    enc = getattr(sys.stdout, "encoding", None)
+    return enc or "utf-8"
+
+
+def _can_encode(text: str) -> bool:
+    try:
+        text.encode(_stdout_encoding())
+        return True
+    except Exception:
+        return False
+
+
+def _safe_text(text: str) -> str:
+    enc = _stdout_encoding()
+    try:
+        text.encode(enc)
+        return text
+    except Exception:
+        return text.encode(enc, errors="replace").decode(enc, errors="replace")
+
+
+def _safe_print(text: str = "") -> None:
+    try:
+        print(text)
+    except UnicodeEncodeError:
+        print(_safe_text(text))
+
+
+def _configure_stdio() -> None:
+    """Best-effort: avoid UnicodeEncodeError on misconfigured terminals (esp. Windows)."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            reconfig = getattr(stream, "reconfigure", None)
+            if callable(reconfig):
+                reconfig(errors="replace")
+        except Exception:
+            pass
+
 def print_banner():
     """Print the Kiwi AI startup banner."""
-    print()
+    # Ensure we never crash on Windows consoles that still default to legacy
+    # encodings (e.g. cp1252). We'll replace unencodable characters instead of
+    # raising UnicodeEncodeError.
+    _configure_stdio()
+
+    # If the terminal can't represent our box-drawing / block chars, fall back
+    # to a plain banner (still functional, just less pretty).
+    h1 = "━" if _can_encode("━") else "-"
+    plain = os.environ.get("KIWI_PLAIN_BANNER") == "1" or not _can_encode("█") or h1 == "-"
+    if plain:
+        _safe_print("")
+        _safe_print("  Kiwi Runtime")
+        _safe_print(f"  {h1 * 72}")
+        _safe_print(f"  {TAGLINE}")
+        _safe_print("")
+        return
+
+    _safe_print("")
 
     # Side-by-side: logo (16 lines) with text (6 lines) vertically centered
     gap = "  "
@@ -1058,21 +1115,22 @@ def print_banner():
         else:
             row = padded_logo
 
-        print(f"  {CB}{row}{RESET}")
+        _safe_print(f"  {CB}{row}{RESET}")
 
-    print(f"  {GREY}{'━' * 72}{RESET}")
-    print()
+    _safe_print(f"  {GREY}{h1 * 72}{RESET}")
+    _safe_print("")
 
 
 def print_status(icon: str, message: str, color: str = C):
     """Print a styled status line."""
-    print(f"  {color}{icon}{RESET}  {message}")
+    _safe_print(f"  {color}{icon}{RESET}  {message}")
 
 
 def print_section(title: str):
     """Print a section header."""
-    print(f"\n  {CB}{title}{RESET}")
-    print(f"  {GREY}{'─' * 40}{RESET}")
+    rule = "─" if _can_encode("─") else "-"
+    _safe_print(f"\n  {CB}{title}{RESET}")
+    _safe_print(f"  {GREY}{rule * 40}{RESET}")
 
 
 def print_cmd_log(request_id: str, message: str, success: bool | None = None):
@@ -1084,7 +1142,7 @@ def print_cmd_log(request_id: str, message: str, success: bool | None = None):
         icon = f"{RED}x{RESET}"
     else:
         icon = f"{C}>{RESET}"
-    print(f"  {icon} {tag} {message}")
+    _safe_print(f"  {icon} {tag} {message}")
 
 
 def print_pty_log(session_id: str, message: str, level: str = "info"):
@@ -1096,7 +1154,7 @@ def print_pty_log(session_id: str, message: str, level: str = "info"):
         icon = f"{GREEN}>{RESET}"
     else:
         icon = f"{C}~{RESET}"
-    print(f"  {icon} {tag} {message}")
+    _safe_print(f"  {icon} {tag} {message}")
 
 
 # ---------------------------------------------------------------------------

{kiwi_code-0.0.18 → kiwi_code-0.0.20}/src/kiwi_tui/runtime_agent.py

@@ -325,6 +325,11 @@ def _spawn_runtime(
     env = os.environ.copy()
     env.setdefault("PYTHONUNBUFFERED", "1")
 
+    # Ensure the runtime doesn't crash on Windows consoles/locales that default
+    # to legacy encodings (cp1252, cp437).
+    env.setdefault("PYTHONUTF8", "1")
+    env.setdefault("PYTHONIOENCODING", "utf-8:replace")
+
     try:
         log_path.parent.mkdir(parents=True, exist_ok=True)
         log_fp = open(log_path, "a", encoding="utf-8", errors="replace")

{kiwi_code-0.0.18 → kiwi_code-0.0.20}/src/kiwi_tui/screens/dashboard.py

@@ -1820,54 +1820,70 @@ class DashboardScreen(Screen):
 
         poll_task = asyncio.create_task(_poll_until_done())
 
+        # Run SSE streaming and polling concurrently. We intentionally do NOT
+        # impose a hard timeout on the SSE stream; long-running actions may
+        # legitimately take more than a few minutes. If the stream ends early
+        # (e.g. network drop), we continue polling until we can fetch a terminal
+        # result. Users can always use /cancel to stop waiting.
+        status_task: asyncio.Task | None = asyncio.create_task(
+            client.stream_action_result(run_id, handle_status_message)
+        )
+
         try:
-            status_task = asyncio.create_task(
-                asyncio.wait_for(
-                    client.stream_action_result(run_id, handle_status_message),
-                    timeout=300.0  # 5 minutes — avoids indefinite hangs
-                )
-            )
+            while not got_final_result:
+                tasks: list[asyncio.Task] = [poll_task]
+                if status_task is not None:
+                    tasks.append(status_task)
 
-            try:
-                # Wait for EITHER the SSE stream to end OR polling to find the result
-                done, pending = await asyncio.wait(
-                    [status_task, poll_task],
+                done, _pending = await asyncio.wait(
+                    tasks,
                     return_when=asyncio.FIRST_COMPLETED,
                 )
-                # Cancel whichever is still running
-                for task in pending:
-                    task.cancel()
+
+                # Polling finished => we have (or attempted) a final result.
+                if poll_task in done:
+                    break
+
+                # Streaming ended first (normal end or error). Keep polling.
+                if status_task is not None and status_task in done:
                     try:
-                        await task
-                    except (asyncio.CancelledError, Exception):
+                        status_task.result()
+                    except asyncio.CancelledError:
                         pass
-                # Check for exceptions in completed tasks
-                for task in done:
-                    if task.exception() and not isinstance(task.exception(), (asyncio.CancelledError, asyncio.TimeoutError)):
-                        logger.error(f"Stream/poll error: {task.exception()}")
-            except asyncio.CancelledError:
-                logger.info(f"Stream cancelled for {run_id}")
-                status_task.cancel()
-                poll_task.cancel()
-                _remove_status_widget()
-                self._set_streaming(False)
-                return
-            except asyncio.TimeoutError:
-                logger.warning(f"SSE timeout for {run_id}")
-                poll_task.cancel()
-                _remove_status_widget()
-                self.add_message("Action timed out waiting for response", "error")
-                self._set_streaming(False)
-                return
+                    except Exception as e:
+                        logger.warning(f"SSE stream ended for {run_id}: {e}")
+                    status_task = None
+
+            # Ensure polling completes (it exits when got_final_result becomes True).
+            if not poll_task.done():
+                await poll_task
         except asyncio.CancelledError:
-            logger.info(f"Stream worker cancelled for {run_id}")
+            logger.info(f"Stream cancelled for {run_id}")
+            if status_task is not None:
+                status_task.cancel()
             poll_task.cancel()
             _remove_status_widget()
             self._set_streaming(False)
             return
         except Exception as e:
-            logger.error(f"SSE error for {run_id}: {e}")
+            logger.error(f"Stream/poll error for {run_id}: {e}")
             poll_task.cancel()
+            _remove_status_widget()
+            self.add_message(
+                f"Lost connection while waiting for result. The run may still be processing. "
+                f"Use /continue {run_id} to reattach.",
+                "error",
+            )
+            self._set_streaming(False)
+            return
+        finally:
+            # If we got the result via polling, stop streaming to avoid leaks.
+            if status_task is not None and not status_task.done():
+                status_task.cancel()
+                try:
+                    await status_task
+                except (asyncio.CancelledError, Exception):
+                    pass
 
         # Always clean up status widget when SSE stream ends
         _remove_status_widget()

{kiwi_code-0.0.18 → kiwi_code-0.0.20}/uv.lock

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