kiwi-code 0.0.4__tar.gz → 0.0.5__tar.gz

{kiwi_code-0.0.4 → kiwi_code-0.0.5}/Makefile

@@ -1,4 +1,4 @@
-.PHONY: run dev cli runtime test-hello install sync clean help
+.PHONY: run dev serve cli runtime test-hello install sync clean help
 
 # Run the Kiwi TUI application
 run:
@@ -8,6 +8,10 @@ run:
 dev:
 	uv run --dev kiwi
 
+# Serve the Kiwi TUI in the browser via textual serve (e.g. make serve PORT=8566)
+serve:
+	uv run textual serve --port $(or $(PORT),8566) -c "python -m kiwi_tui.main"
+
 # Run the Kiwi CLI
 cli:
 	uv run kiwicli
@@ -53,6 +57,7 @@ help:
 	@echo "Commands:"
 	@echo "  run          - Run the Kiwi TUI application (kiwi)"
 	@echo "  dev          - Run TUI in development mode (with live reload)"
+	@echo "  serve        - Serve the TUI in the browser (PORT=8566 make serve)"
 	@echo "  cli          - Run the Kiwi CLI (kiwicli)"
 	@echo "  runtime      - Run the Kiwi Runtime agent (kiwi-runtime)"
 	@echo "                 e.g. make runtime ARGS=\"connect --server app\""

{kiwi_code-0.0.4 → kiwi_code-0.0.5}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.4"
+version = "0.0.5"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.13,<4.0"

{kiwi_code-0.0.4 → kiwi_code-0.0.5}/src/kiwi_runtime/main.py

@@ -370,9 +370,12 @@ def _is_within_allowed(resolved_path: str, allowed_dirs: list[str]) -> bool:
 # Core logic
 # ---------------------------------------------------------------------------
 
-async def login(http_base_url: str, email: str, password: str) -> str:
-    """Authenticate with email/password and return the JWT access token."""
-    url = f"{http_base_url}/v1/auth/token"
+async def login(http_base_url: str, email: str, password: str) -> dict:
+    """Authenticate with email/password via session API.
+
+    Returns dict with access_token, refresh_token, and expires_in.
+    """
+    url = f"{http_base_url}/v1/auth"
     async with httpx.AsyncClient(timeout=30) as client:
         resp = await client.post(
             url,
@@ -388,10 +391,41 @@ async def login(http_base_url: str, email: str, password: str) -> str:
             raise Exception(f"Login failed (HTTP {resp.status_code}): {detail}")
 
         body = resp.json()
-        token = body.get("access_token")
-        if not token:
-            raise Exception(f"No access_token in response: {body}")
-        return token
+        session = body.get("session")
+        if not session or not session.get("access_token"):
+            raise Exception(f"No session in response: {body}")
+        return {
+            "access_token": session["access_token"],
+            "refresh_token": session.get("refresh_token"),
+            "expires_in": session.get("expires_in"),
+        }
+
+
+async def refresh_access_token(http_base_url: str, refresh_token: str) -> dict:
+    """Use a refresh token to obtain a new access token.
+
+    Returns dict with access_token, refresh_token, and expires_in.
+    """
+    url = f"{http_base_url}/v1/auth/session/refresh"
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(url, params={"refresh_token": refresh_token})
+        if resp.status_code != 200:
+            detail = resp.text
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                pass
+            raise Exception(f"Token refresh failed (HTTP {resp.status_code}): {detail}")
+
+        body = resp.json()
+        session = body.get("session")
+        if not session or not session.get("access_token"):
+            raise Exception(f"No session in refresh response: {body}")
+        return {
+            "access_token": session["access_token"],
+            "refresh_token": session.get("refresh_token"),
+            "expires_in": session.get("expires_in"),
+        }
 
 
 async def run_command(
@@ -668,13 +702,86 @@ class PipeProcess:
                     pass
 
 
+def _get_shared_token_path() -> str | None:
+    """Return the path to the shared token file written by the TUI."""
+    try:
+        from kiwi_tui.runtime_manager import token_path
+        return str(token_path())
+    except ImportError:
+        return None
+
+
+def _get_shared_refresh_token_path() -> str | None:
+    """Return the path to the shared refresh token file written by the TUI."""
+    try:
+        from kiwi_tui.runtime_manager import refresh_token_path
+        return str(refresh_token_path())
+    except ImportError:
+        return None
+
+
+def _read_file(path: str | None) -> str | None:
+    """Read a token from a file path, returning None on failure."""
+    if not path:
+        return None
+    try:
+        val = open(path).read().strip()
+        return val or None
+    except OSError:
+        return None
+
+
+def _write_file(path: str | None, value: str) -> None:
+    """Write a value to a file with restricted permissions."""
+    if not path:
+        return
+    try:
+        with open(path, "w") as f:
+            f.write(value)
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+async def _watch_token_file(ws, current_token: str, token_file: str | None):
+    """Periodically check the shared token file for updates.
+
+    When the TUI refreshes the token it writes the new value to disk.
+    This coroutine detects the change and sends a fresh auth message.
+    """
+    if not token_file:
+        return
+
+    last_token = current_token
+    while True:
+        await asyncio.sleep(30)  # check every 30 seconds
+        try:
+            new_token = open(token_file).read().strip()
+            if new_token and new_token != last_token:
+                last_token = new_token
+                print_status("~", "Token refreshed by TUI, re-authenticating...", C)
+                await ws.send(json.dumps({"type": "auth", "token": new_token}))
+                resp = json.loads(await ws.recv())
+                if resp.get("type") == "auth_ok":
+                    print_status(">", "Re-authenticated with refreshed token", GREEN)
+                else:
+                    print_status("!", f"Re-auth response: {resp.get('type')}", YELLOW)
+        except (OSError, json.JSONDecodeError):
+            pass
+        except Exception as e:
+            print_status("!", f"Token watch error: {e}", YELLOW)
+
+
 async def connect(
     ws_url: str,
     token: str,
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
-):
-    """Connect to the server WebSocket and process commands."""
+) -> str:
+    """Connect to the server WebSocket and process commands.
+
+    Returns a status string: "ok", "auth_failed", or "error".
+    """
     ws_endpoint = f"{ws_url}/v1/terminal/ws/connect"
     print_status("~", f"Connecting to {BOLD}{ws_endpoint}{RESET}", C)
 
@@ -685,14 +792,14 @@ async def connect(
 
             if auth_resp.get("type") == "error":
                 print_status("x", f"Auth failed: {auth_resp.get('message')}", RED)
-                return
+                return "auth_failed"
 
             if auth_resp.get("type") == "auth_ok":
                 user_id = auth_resp.get('user_id', 'unknown')
                 print_status(">", f"Connected as {BOLD}{user_id}{RESET}", GREEN)
             else:
                 print_status("x", f"Unexpected response: {auth_resp}", RED)
-                return
+                return "auth_failed"
 
             print()
             if mode == "restricted" and allowed_dirs:
@@ -708,6 +815,12 @@ async def connect(
 
             active_pty_sessions: dict[str, PTYProcess] = {}
 
+            # Start background task to watch for token refreshes from TUI
+            token_file = _get_shared_token_path()
+            token_watcher = asyncio.create_task(
+                _watch_token_file(ws, token, token_file)
+            )
+
             try:
                 async for message in ws:
                     msg = json.loads(message)
@@ -817,6 +930,7 @@ async def connect(
                     else:
                         print_status("?", f"Unknown message: {msg_type}", YELLOW)
             finally:
+                token_watcher.cancel()
                 for sid, pty_proc in active_pty_sessions.items():
                     try:
                         await pty_proc.close()
@@ -826,12 +940,17 @@ async def connect(
     except websockets.exceptions.ConnectionClosed as e:
         print()
         print_status("!", f"Connection closed: {e}", YELLOW)
+        return "error"
     except ConnectionRefusedError:
         print()
         print_status("x", f"Could not connect to {ws_endpoint}. Is the server running?", RED)
+        return "error"
     except Exception as e:
         print()
         print_status("x", f"Error: {e}", RED)
+        return "error"
+
+    return "ok"
 
 
 def main():
@@ -929,7 +1048,12 @@ def main():
 
         loop = asyncio.new_event_loop()
 
+        token_file = _get_shared_token_path()
+        refresh_file = _get_shared_refresh_token_path()
+
         provided_token = args.token or os.environ.get("KIWI_AUTH_TOKEN")
+        refresh_token = _read_file(refresh_file)  # May have been saved by TUI
+
         if provided_token:
             # Use provided token — skip interactive login
             token = provided_token
@@ -947,8 +1071,14 @@ def main():
 
             print_status("~", f"Authenticating with {BOLD}{http_url}{RESET}...", C)
             try:
-                token = loop.run_until_complete(login(http_url, email, password))
+                session = loop.run_until_complete(login(http_url, email, password))
+                token = session["access_token"]
+                refresh_token = session.get("refresh_token")
                 print_status(">", "Login successful!", GREEN)
+                # Save tokens to shared files
+                _write_file(token_file, token)
+                if refresh_token:
+                    _write_file(refresh_file, refresh_token)
             except Exception as e:
                 print_status("x", f"Login failed: {e}", RED)
                 loop.close()
@@ -970,16 +1100,68 @@ def main():
 
         signal.signal(signal.SIGINT, lambda *_: shutdown())
 
-        try:
-            loop.run_until_complete(connect(ws_url, token, mode=mode, allowed_dirs=allowed_dirs))
-        except asyncio.CancelledError:
-            pass
-        finally:
-            loop.close()
-            print()
-            print(f"  {GREY}{'─' * 50}{RESET}")
-            print_status(">", "Disconnected. Goodbye!", C)
+        # Auto-reconnect loop with token refresh
+        backoff = 5
+        max_backoff = 60
+
+        while not _shutting_down:
+            # Read latest tokens from shared files before each attempt
+            fresh_token = _read_file(token_file)
+            if fresh_token:
+                token = fresh_token
+            fresh_refresh = _read_file(refresh_file)
+            if fresh_refresh:
+                refresh_token = fresh_refresh
+
+            try:
+                status = loop.run_until_complete(
+                    connect(ws_url, token, mode=mode, allowed_dirs=allowed_dirs)
+                )
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                status = "error"
+
+            if _shutting_down:
+                break
+
+            # On auth failure, try to refresh the token before reconnecting
+            if status == "auth_failed" and refresh_token:
+                print_status("~", "Access token expired, refreshing...", C)
+                try:
+                    session = loop.run_until_complete(
+                        refresh_access_token(http_url, refresh_token)
+                    )
+                    token = session["access_token"]
+                    if session.get("refresh_token"):
+                        refresh_token = session["refresh_token"]
+                    print_status(">", "Token refreshed successfully", GREEN)
+                    # Save refreshed tokens to shared files
+                    _write_file(token_file, token)
+                    if refresh_token:
+                        _write_file(refresh_file, refresh_token)
+                    backoff = 2  # Quick retry after successful refresh
+                except Exception as e:
+                    print_status("x", f"Token refresh failed: {e}", RED)
+
+            # Reset backoff after a successful session
+            if status == "ok":
+                backoff = 5
+
             print()
+            print_section("Reconnecting")
+            print_status("~", f"Reconnecting in {backoff}s...", C)
+            try:
+                loop.run_until_complete(asyncio.sleep(backoff))
+            except asyncio.CancelledError:
+                break
+            backoff = min(backoff * 2, max_backoff)
+
+        loop.close()
+        print()
+        print(f"  {GREY}{'─' * 50}{RESET}")
+        print_status(">", "Disconnected. Goodbye!", C)
+        print()
     else:
         print_banner()
         parser.print_help()

{kiwi_code-0.0.4 → kiwi_code-0.0.5}/src/kiwi_tui/main.py

@@ -131,6 +131,7 @@ class AutobotsTUI(App):
         if self.token_manager.is_authenticated():
             logger.info("User is authenticated, showing dashboard")
             self._start_kiwi_session()
+            self._start_token_refresh()
             try:
                 self.switch_screen("dashboard")
             except IndexError:
@@ -270,6 +271,53 @@ class AutobotsTUI(App):
         self._kiwi_pid = None
         self._close_log_tail()
 
+    # ------------------------------------------------------------------
+    # 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)
+        # Write current tokens to shared files so runtime can read them
+        if self._kiwi_token:
+            runtime_manager.save_token(self._kiwi_token)
+        tokens = self.token_manager.load_tokens()
+        if tokens and tokens.refresh_token:
+            runtime_manager.save_refresh_token(tokens.refresh_token)
+
+    def _refresh_token_if_needed(self) -> None:
+        """Check token expiry and refresh if needed."""
+        tokens = self.token_manager.load_tokens()
+        if not tokens:
+            logger.debug("No tokens to refresh")
+            return
+
+        if not tokens.is_expired():
+            logger.debug("Token still valid, skipping refresh")
+            return
+
+        logger.info("Token expired or near expiry, refreshing...")
+        success, new_tokens, message = self.autobots_client.refresh_token(
+            tokens.refresh_token
+        )
+
+        if success and new_tokens:
+            logger.info("Token refreshed successfully")
+            # Save to disk
+            self.token_manager.save_tokens(new_tokens)
+            # Update TUI client
+            self.autobots_client.update_token(new_tokens.access_token)
+            # Update shared state
+            self._kiwi_token = new_tokens.access_token
+            # Write to runtime directory so the runtime process can pick it up
+            runtime_manager.save_token(new_tokens.access_token)
+            if new_tokens.refresh_token:
+                runtime_manager.save_refresh_token(new_tokens.refresh_token)
+        else:
+            logger.error(f"Token refresh failed: {message}")
+
     # ------------------------------------------------------------------
 
     def action_runtime_logs(self) -> None:
@@ -315,23 +363,50 @@ class AutobotsTUI(App):
         self.exit()
 
 
-def main():
-    """Run the Autobots TUI application."""
-    # Setup logging
+def _run_tui():
+    """Run the TUI in the terminal."""
     config_manager = ConfigManager()
     config = config_manager.load()
     setup_logging(log_level=config.log_level)
 
-    logger.info("="*60)
+    logger.info("=" * 60)
     logger.info("Starting Autobots TUI")
-    logger.info("="*60)
+    logger.info("=" * 60)
 
-    # Run app
     app = AutobotsTUI(config_manager=config_manager)
     app.run()
 
     logger.info("Autobots TUI terminated")
 
 
+def _serve_tui(port: int = 8566):
+    """Serve the TUI in the browser via textual serve."""
+    import sys
+    from textual_serve.server import Server
+
+    server = Server(f"{sys.executable} -m kiwi_tui.main", port=port)
+    server.serve()
+
+
+def main():
+    """Entry point for the kiwi command."""
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="kiwi", description="Kiwi Code TUI")
+    subparsers = parser.add_subparsers(dest="command")
+
+    serve_parser = subparsers.add_parser("serve", help="Serve the TUI in the browser")
+    serve_parser.add_argument(
+        "--port", "-p", type=int, default=8566, help="Port to serve on (default: 8566)"
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "serve":
+        _serve_tui(port=args.port)
+    else:
+        _run_tui()
+
+
 if __name__ == "__main__":
     main()

{kiwi_code-0.0.4 → kiwi_code-0.0.5}/src/kiwi_tui/runtime_manager.py

@@ -58,6 +58,52 @@ def log_path(cwd: str | None = None) -> Path:
     return runtime_dir(cwd) / "log"
 
 
+def token_path(cwd: str | None = None) -> Path:
+    """Return the shared token file path for a directory's runtime."""
+    return runtime_dir(cwd) / "token"
+
+
+def refresh_token_path(cwd: str | None = None) -> Path:
+    """Return the shared refresh token file path for a directory's runtime."""
+    return runtime_dir(cwd) / "refresh_token"
+
+
+def save_token(token: str, cwd: str | None = None) -> None:
+    """Write a refreshed access token so the runtime can pick it up."""
+    tp = token_path(cwd)
+    tp.write_text(token)
+    tp.chmod(0o600)
+
+
+def save_refresh_token(token: str, cwd: str | None = None) -> None:
+    """Write the refresh token so the runtime can refresh on its own."""
+    tp = refresh_token_path(cwd)
+    tp.write_text(token)
+    tp.chmod(0o600)
+
+
+def read_token(cwd: str | None = None) -> str | None:
+    """Read the shared access token (returns None if missing)."""
+    tp = token_path(cwd)
+    if not tp.exists():
+        return None
+    try:
+        return tp.read_text().strip() or None
+    except OSError:
+        return None
+
+
+def read_refresh_token(cwd: str | None = None) -> str | None:
+    """Read the shared refresh token (returns None if missing)."""
+    tp = refresh_token_path(cwd)
+    if not tp.exists():
+        return None
+    try:
+        return tp.read_text().strip() or None
+    except OSError:
+        return None
+
+
 def stop_runtime(cwd: str | None = None) -> bool:
     """Stop the runtime for a directory. Returns True if a process was stopped."""
     pid = get_running_pid(cwd)

{kiwi_code-0.0.4 → kiwi_code-0.0.5}/src/kiwi_tui/screens/login.py

@@ -280,6 +280,7 @@ class LoginScreen(Screen):
                 # Share token with kiwi CLI session and start it
                 self.app._kiwi_token = tokens.access_token
                 self.app._start_kiwi_session()
+                self.app._start_token_refresh()
 
                 # Notify app of successful login
                 self.app.post_message(LoginSuccess(tokens))