kiwi-code 0.0.4__py3-none-any.whl

kiwi_tui/main.py

@@ -0,0 +1,337 @@
+"""Main entry point for Autobots TUI application."""
+
+import collections
+import os
+import subprocess
+
+from textual.app import App
+from textual.binding import Binding
+from loguru import logger
+
+from .logger import setup_logging
+from .config import ConfigManager
+from .client import AutobotsClientWrapper
+from .auth import TokenManager
+from . import runtime_manager
+from .screens import LoginScreen, DashboardScreen, AutobotsScreen, ActionsScreen, RuntimeLogsScreen
+
+
+class AutobotsTUI(App):
+    """A modern Textual app for managing Autobots."""
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+
+    Header {
+        background: #006666;
+        color: #00ffff;
+    }
+
+    Footer {
+        background: #006666;
+    }
+
+    Footer > .footer--key {
+        background: #008888;
+        color: #00ffff;
+    }
+    """
+
+    TITLE = "Kiwi Code"
+    SUB_TITLE = ""
+
+    SCREENS = {
+        "login": LoginScreen,
+        "dashboard": DashboardScreen,
+        "autobots": AutobotsScreen,
+        "actions": ActionsScreen,
+        "runtime_logs": RuntimeLogsScreen,
+    }
+
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit", show=True),
+        Binding("ctrl+d", "toggle_dark", "Toggle Dark Mode", show=False),
+        Binding("ctrl+r", "runtime_logs", "Runtime Logs", show=True),
+        Binding("ctrl+l", "logout", "Logout", show=False),
+    ]
+
+    # Map backend HTTP URLs to kiwi connect server presets
+    _KIWI_SERVER_MAP = {
+        "https://api.meetkiwi.ai": "app",
+        "https://dev.api.myautobots.com": "dev",
+        "http://localhost:8000": "local",
+    }
+
+    # Max lines to keep in the runtime log buffer
+    _KIWI_LOG_BUFFER_SIZE = 5000
+
+    def __init__(self, config_manager: ConfigManager | None = None, token_manager: TokenManager | None = None):
+        """Initialize Autobots TUI app.
+
+        Args:
+            config_manager: Configuration manager instance
+            token_manager: Token manager instance
+        """
+        super().__init__()
+        self.config_manager = config_manager or ConfigManager()
+        self.config = self.config_manager.config
+
+        self._kiwi_token = None  # Set after auth for kiwi CLI session
+        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)
+
+        # Initialize token manager
+        self.token_manager = token_manager or TokenManager()
+
+        # Check for existing tokens
+        tokens = self.token_manager.load_tokens()
+        access_token = None
+
+        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)
+                success, new_tokens, message = temp_client.refresh_token(tokens.refresh_token)
+
+                if success and new_tokens:
+                    logger.info("Token refreshed successfully")
+                    self.token_manager.save_tokens(new_tokens)
+                    access_token = new_tokens.access_token
+                else:
+                    logger.warning(f"Token refresh failed: {message}")
+                    self.token_manager.clear_tokens()
+            else:
+                logger.info("Valid access token found")
+                access_token = tokens.access_token
+
+        # Share token with kiwi CLI session
+        self._kiwi_token = access_token
+
+        # Initialize autobots client
+        self.autobots_client = AutobotsClientWrapper(
+            base_url=self.config.backend_url,
+            access_token=access_token,
+            api_key=self.config.api_key,
+        )
+
+    def on_mount(self) -> None:
+        """Called when app is mounted."""
+        logger.info("Autobots TUI on_mount called")
+        logger.info(f"Backend URL: {self.config.backend_url}")
+
+        # Set theme
+        self.dark = self.config.theme == "dark"
+
+        # Check if user is authenticated
+        if self.token_manager.is_authenticated():
+            logger.info("User is authenticated, showing dashboard")
+            self._start_kiwi_session()
+            try:
+                self.switch_screen("dashboard")
+            except IndexError:
+                self.push_screen("dashboard")
+        else:
+            logger.info("User not authenticated, showing login screen")
+            try:
+                self.switch_screen("login")
+            except IndexError:
+                self.push_screen("login")
+
+    @property
+    def runtime_log_cmd(self) -> str:
+        """Derive the kiwi connect command from the configured backend_url."""
+        # Allow env var override
+        override = os.getenv("KIWI_CODE_RUNTIME_LOG_CMD")
+        if override:
+            return override
+
+        import sys
+        python = sys.executable
+
+        backend_url = self.config.backend_url.rstrip("/")
+        server = self._KIWI_SERVER_MAP.get(backend_url)
+        if server:
+            cmd = f"{python} -m kiwi_runtime connect --server {server}"
+        else:
+            # Custom URL — convert http(s) to ws(s)
+            ws_url = backend_url.replace("https://", "wss://").replace("http://", "ws://")
+            cmd = f"{python} -m kiwi_runtime connect --server {ws_url}"
+
+        return cmd
+
+    # ------------------------------------------------------------------
+    # Persistent kiwi runtime (per working directory, survives TUI restarts)
+    # ------------------------------------------------------------------
+
+    def _start_kiwi_session(self) -> None:
+        """Start a new kiwi-runtime for this directory, or attach if already running."""
+        existing_pid = runtime_manager.get_running_pid()
+        if existing_pid:
+            logger.info(f"Kiwi runtime already running (PID {existing_pid})")
+            self._kiwi_pid = existing_pid
+            self._start_log_tail()
+            return
+
+        cmd = self.runtime_log_cmd
+        if not cmd:
+            return
+
+        logger.info(f"Starting kiwi runtime: {cmd}")
+        try:
+            env = os.environ.copy()
+            env["PYTHONUNBUFFERED"] = "1"
+
+            token = self._kiwi_token
+            if token:
+                env["KIWI_AUTH_TOKEN"] = token
+
+            rt_log_path = runtime_manager.log_path()
+            log_fp = open(rt_log_path, "a")
+
+            proc = subprocess.Popen(
+                cmd,
+                shell=True,
+                stdin=subprocess.DEVNULL,
+                stdout=log_fp,
+                stderr=subprocess.STDOUT,
+                start_new_session=True,
+                env=env,
+            )
+            log_fp.close()  # Child inherited the fd via fork
+
+            runtime_manager.save_pid(proc.pid)
+            self._kiwi_pid = proc.pid
+
+            self._start_log_tail()
+            logger.info(f"Kiwi runtime started (PID {proc.pid})")
+        except Exception as e:
+            logger.error(f"Failed to start kiwi runtime: {e}")
+
+    def _start_log_tail(self) -> None:
+        """Open the runtime log file for tailing."""
+        if self._log_fp is not None:
+            return  # Already tailing
+
+        rt_log_path = runtime_manager.log_path()
+        if not rt_log_path.exists():
+            return
+
+        try:
+            self._log_fp = open(rt_log_path, "r", encoding="utf-8", errors="replace")
+            # Seek near end so we don't replay the entire history
+            size = rt_log_path.stat().st_size
+            if size > 65536:
+                self._log_fp.seek(size - 65536)
+            self.set_interval(0.1, self._drain_kiwi_output)
+            logger.info("Started tailing runtime log")
+        except OSError as e:
+            logger.error(f"Failed to tail runtime log: {e}")
+
+    def _drain_kiwi_output(self) -> None:
+        """Read new lines from the runtime log file and buffer them."""
+        fp = self._log_fp
+        if fp is None:
+            return
+
+        chunk = fp.read()
+        if not chunk:
+            # No new output — check if runtime is still alive
+            if self._kiwi_pid:
+                try:
+                    os.kill(self._kiwi_pid, 0)
+                except ProcessLookupError:
+                    logger.info("Kiwi runtime exited, restarting...")
+                    self._kiwi_pid = None
+                    self._close_log_tail()
+                    self._start_kiwi_session()
+            return
+
+        for line in chunk.splitlines():
+            self._kiwi_log_lines.append(line)
+
+    def _close_log_tail(self) -> None:
+        """Close the log file we are tailing (does NOT stop the runtime)."""
+        fp = self._log_fp
+        if fp:
+            try:
+                fp.close()
+            except OSError:
+                pass
+            self._log_fp = None
+
+    def _stop_runtime(self) -> None:
+        """Explicitly stop the kiwi-runtime for the current directory."""
+        runtime_manager.stop_runtime()
+        self._kiwi_pid = None
+        self._close_log_tail()
+
+    # ------------------------------------------------------------------
+
+    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"
+        self.config_manager.update(theme=theme)
+        logger.info(f"Theme changed to {theme}")
+        self.notify(f"Theme: {theme}", severity="information")
+
+    def action_logout(self) -> None:
+        """Logout user and return to login screen."""
+        logger.info("User logout requested")
+
+        # Detach from runtime logs — do NOT stop the runtime process
+        self._close_log_tail()
+        self._kiwi_pid = None
+
+        # Clear tokens
+        self.token_manager.clear_tokens()
+
+        # Reset client to unauthenticated
+        self.autobots_client = AutobotsClientWrapper(
+            base_url=self.config.backend_url,
+        )
+
+        # Switch to login screen
+        self.switch_screen("login")
+        self.notify("Logged out successfully", severity="information")
+
+    def action_quit(self) -> None:
+        """Quit the application."""
+        logger.info("Autobots TUI shutting down")
+        # Detach from runtime logs — do NOT stop the runtime process
+        self._close_log_tail()
+        # Close autobots client connection
+        if hasattr(self, 'autobots_client'):
+            self.autobots_client.close()
+        self.exit()
+
+
+def main():
+    """Run the Autobots TUI application."""
+    # Setup logging
+    config_manager = ConfigManager()
+    config = config_manager.load()
+    setup_logging(log_level=config.log_level)
+
+    logger.info("="*60)
+    logger.info("Starting Autobots TUI")
+    logger.info("="*60)
+
+    # Run app
+    app = AutobotsTUI(config_manager=config_manager)
+    app.run()
+
+    logger.info("Autobots TUI terminated")
+
+
+if __name__ == "__main__":
+    main()

kiwi_tui/models.py

@@ -0,0 +1,85 @@
+"""Pydantic models for Autobots TUI."""
+
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Optional, Any
+from pydantic import BaseModel, Field
+
+
+class ActionStatus(str, Enum):
+    """Status of an action execution."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class AutobotType(str, Enum):
+    """Type of autobot."""
+    CHAT = "chat"
+    SEARCH = "search"
+    AUTOMATION = "automation"
+    ANALYSIS = "analysis"
+
+
+class Autobot(BaseModel):
+    """Represents an autobot instance."""
+    id: str
+    name: str
+    type: AutobotType
+    description: str
+    enabled: bool = True
+    created_at: datetime = Field(default_factory=datetime.now)
+    last_run: Optional[datetime] = None
+    run_count: int = 0
+
+
+class Action(BaseModel):
+    """Represents an action that can be executed."""
+    id: str
+    name: str
+    description: str
+    autobot_id: str
+    parameters: dict[str, Any] = Field(default_factory=dict)
+
+
+class ActionExecution(BaseModel):
+    """Represents an action execution instance."""
+    id: str
+    action_id: str
+    status: ActionStatus
+    started_at: datetime = Field(default_factory=datetime.now)
+    completed_at: Optional[datetime] = None
+    result: Optional[dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+class AuthTokens(BaseModel):
+    """Authentication tokens."""
+    access_token: str
+    refresh_token: str
+    token_type: str = "Bearer"
+    expires_at: Optional[datetime] = None
+
+    def is_expired(self) -> bool:
+        """Check if access token is expired."""
+        if not self.expires_at:
+            return False
+        # Add 60 second buffer before expiry
+        return datetime.now() >= (self.expires_at - timedelta(seconds=60))
+
+
+class LoginCredentials(BaseModel):
+    """Login credentials."""
+    username: str
+    password: str
+
+
+class AppConfig(BaseModel):
+    """Application configuration."""
+    backend_url: str = "https://dev.api.myautobots.com"#"https://api.meetkiwi.ai"
+    api_key: Optional[str] = None
+    log_level: str = "INFO"
+    theme: str = "dark"
+    refresh_interval: int = 5

kiwi_tui/runtime_manager.py

@@ -0,0 +1,130 @@
+"""Shared helpers for managing per-directory kiwi-runtime processes.
+
+Each working directory gets its own runtime, identified by a hash of the
+absolute path.  State is stored under ~/.autobots-tui/runtimes/<key>/:
+    pid  — PID of the running process
+    log  — stdout/stderr of the runtime
+    cwd  — the working directory this runtime is scoped to
+"""
+
+import hashlib
+import os
+import signal
+import time
+from pathlib import Path
+
+RUNTIMES_DIR = Path.home() / ".autobots-tui" / "runtimes"
+
+
+def runtime_key(cwd: str | None = None) -> str:
+    """Generate a short hash key for a working directory."""
+    if cwd is None:
+        cwd = os.getcwd()
+    return hashlib.sha256(os.path.realpath(cwd).encode()).hexdigest()[:12]
+
+
+def runtime_dir(cwd: str | None = None) -> Path:
+    """Return the runtime state directory for a given working directory."""
+    d = RUNTIMES_DIR / runtime_key(cwd)
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def get_running_pid(cwd: str | None = None) -> int | None:
+    """Return PID of a running runtime for the directory, or None."""
+    pid_path = runtime_dir(cwd) / "pid"
+    if not pid_path.exists():
+        return None
+    try:
+        pid = int(pid_path.read_text().strip())
+        os.kill(pid, 0)
+        return pid
+    except (ValueError, ProcessLookupError, PermissionError):
+        pid_path.unlink(missing_ok=True)
+        return None
+
+
+def save_pid(pid: int, cwd: str | None = None) -> None:
+    """Record a runtime PID and its working directory."""
+    if cwd is None:
+        cwd = os.getcwd()
+    rd = runtime_dir(cwd)
+    (rd / "pid").write_text(str(pid))
+    (rd / "cwd").write_text(os.path.realpath(cwd))
+
+
+def log_path(cwd: str | None = None) -> Path:
+    """Return the log file path for a directory's runtime."""
+    return runtime_dir(cwd) / "log"
+
+
+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)
+    if not pid:
+        return False
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+        for _ in range(20):
+            time.sleep(0.1)
+            try:
+                os.kill(pid, 0)
+            except ProcessLookupError:
+                break
+        else:
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+    except ProcessLookupError:
+        pass
+
+    pid_path = runtime_dir(cwd) / "pid"
+    pid_path.unlink(missing_ok=True)
+    return True
+
+
+def list_all() -> list[dict]:
+    """List all known runtimes with their status."""
+    if not RUNTIMES_DIR.exists():
+        return []
+
+    results = []
+    for entry in sorted(RUNTIMES_DIR.iterdir()):
+        if not entry.is_dir():
+            continue
+        cwd_file = entry / "cwd"
+        pid_file = entry / "pid"
+        if not cwd_file.exists():
+            continue
+
+        cwd = cwd_file.read_text().strip()
+        pid = None
+        running = False
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+                os.kill(pid, 0)
+                running = True
+            except (ValueError, ProcessLookupError, PermissionError):
+                pid_file.unlink(missing_ok=True)
+                pid = None
+
+        results.append({
+            "key": entry.name,
+            "cwd": cwd,
+            "pid": pid,
+            "running": running,
+        })
+    return results
+
+
+def stop_all() -> int:
+    """Stop all running runtimes. Returns count of processes stopped."""
+    count = 0
+    for rt in list_all():
+        if rt["running"]:
+            if stop_runtime(rt["cwd"]):
+                count += 1
+    return count

kiwi_tui/screens/__init__.py

@@ -0,0 +1,9 @@
+"""Screens for Autobots TUI."""
+
+from .login import LoginScreen
+from .dashboard import DashboardScreen
+from .autobots import AutobotsScreen
+from .actions import ActionsScreen
+from .runtime_logs import RuntimeLogsScreen
+
+__all__ = ["LoginScreen", "DashboardScreen", "AutobotsScreen", "ActionsScreen", "RuntimeLogsScreen"]