kiwi-code 0.0.4__py3-none-any.whl

kiwi_tui/screens/login.py

@@ -0,0 +1,320 @@
+"""Login screen for Autobots TUI."""
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.containers import Container, Vertical, Center, Horizontal
+from textual.widgets import Header, Footer, Static, Input, Button
+from textual.validation import Length
+from textual.message import Message
+from loguru import logger
+
+from ..models import LoginCredentials
+from ..widgets import ActionButton
+
+
+class LoginScreen(Screen):
+    """Screen for user authentication."""
+
+    AUTO_FOCUS = None  # Prevent automatic focus changes
+
+    CSS = """
+    LoginScreen {
+        background: $surface;
+        layout: vertical;
+    }
+
+    #login-container {
+        width: 100%;
+        height: 1fr;
+        min-height: 20;
+        border: none;
+        background: transparent;
+        padding: 4 8;
+        overflow-y: auto;
+    }
+
+    #logo-container {
+        width: 100%;
+        height: auto;
+        margin-bottom: 2;
+        content-align: left top;
+    }
+
+    #logo {
+        color: #5fffff; /* Cyan-ish */
+        width: auto;
+    }
+
+    #logo-text-container {
+        margin-left: 2;
+        height: auto;
+    }
+
+    #logo-text {
+        color: #5fffff;
+        text-style: bold;
+        height: auto;
+    }
+
+    #logo-subtitle {
+        color: #5fffff;
+        height: auto;
+    }
+
+    .divider {
+        width: 100%;
+        height: 1;
+        border-bottom: solid #444444;
+        margin-bottom: 2;
+    }
+
+    .info-row {
+        height: auto;
+        margin-bottom: 0;
+    }
+
+    .info-label {
+        color: #5fffff;
+        width: auto;
+        margin-right: 1;
+    }
+
+    .info-value {
+        color: $text;
+    }
+
+    .section-header {
+        color: #5fffff;
+        text-style: bold;
+        margin-top: 2;
+        margin-bottom: 1;
+        border-bottom: solid #444444;
+        width: 40;
+    }
+
+    .input-prompt {
+        color: #5fffff;
+        width: auto;
+        margin-right: 1;
+    }
+
+    .form-group {
+        layout: horizontal;
+        height: 1;
+        margin: 0;
+    }
+
+    Input {
+        width: 40;
+        background: transparent;
+        border: none;
+        padding: 0;
+        height: 1;
+        color: $text;
+    }
+
+    Input:focus {
+        border: none;
+    }
+
+    #status-message {
+        margin-top: 1;
+        height: auto;
+    }
+
+    .status-line {
+        height: auto;
+    }
+
+    .status-symbol-success {
+        color: $success;
+        margin-right: 1;
+    }
+
+    .status-symbol-pending {
+        color: #5fffff;
+        margin-right: 1;
+    }
+
+    .status-symbol-error {
+        color: $error;
+        margin-right: 1;
+    }
+
+    #button-container {
+        display: none; /* Hide button to match sleek look */
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "quit", "Quit"),
+        ("ctrl+c", "quit", "Quit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose login screen widgets."""
+        yield Header()
+
+        with Container(id="login-container"):
+            # Logo Section
+            with Horizontal(id="logo-container"):
+                logo_ascii = (
+                    "      #\n"
+                    "    #####\n"
+                    "  #########\n"
+                    " ###########\n"
+                    "#############\n"
+                    " ###########\n"
+                    "  #########\n"
+                    "    #####\n"
+                    "      #"
+                )
+                yield Static(logo_ascii, id="logo")
+                with Vertical(id="logo-text-container"):
+                    yield Static("KIWI AI", id="logo-text")
+                    yield Static("Terminal Agent for AI-Powered Automation", id="logo-subtitle")
+
+            yield Static("", classes="divider")
+
+            # Environment Info
+            with Horizontal(classes="info-row"):
+                yield Static("> Server:", classes="info-label")
+                yield Static(f"app ({self.app.config.backend_url})", classes="info-value")
+            
+            with Horizontal(classes="info-row"):
+                yield Static("> Mode:", classes="info-label")
+                yield Static("restricted", classes="info-value")
+
+            yield Static("Authentication", classes="section-header")
+
+            with Horizontal(classes="form-group"):
+                yield Static("> Email:", classes="input-prompt")
+                yield Input(
+                    placeholder="email@example.com",
+                    id="username-input",
+                )
+
+            with Horizontal(classes="form-group"):
+                yield Static("> Password:", classes="input-prompt")
+                yield Input(
+                    placeholder="••••••••",
+                    password=True,
+                    id="password-input",
+                )
+
+            yield Static("", id="status-message")
+
+            with Center(id="button-container"):
+                yield ActionButton("Sign In", variant="success", id="btn-login")
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        logger.info("Login screen mounted")
+        # Focus on username input after a brief delay to ensure DOM is ready
+        try:
+            username_input = self.query_one("#username-input", Input)
+            self.set_timer(0.1, lambda: username_input.focus())
+        except Exception as e:
+            logger.error(f"Error focusing username input: {e}")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        if event.button.id == "btn-login":
+            self.action_login()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle input submission (Enter key)."""
+        if event.input.id == "username-input":
+            # Move to password field
+            self.query_one("#password-input", Input).focus()
+        elif event.input.id == "password-input":
+            # Submit login
+            self.action_login()
+
+    def action_login(self) -> None:
+        """Attempt to login with provided credentials."""
+        username_input = self.query_one("#username-input", Input)
+        password_input = self.query_one("#password-input", Input)
+        status_widget = self.query_one("#status-message", Static)
+
+        username = username_input.value.strip()
+        password = password_input.value
+
+        # Validate inputs
+        if not username:
+            status_widget.update("~ Please enter your email")
+            status_widget.styles.color = "red"
+            username_input.focus()
+            return
+
+        if not password:
+            status_widget.update("~ Please enter your password")
+            status_widget.styles.color = "red"
+            password_input.focus()
+            return
+
+        # Show loading state
+        status_widget.styles.color = "#5fffff"
+        status_widget.update(f"~ Authenticating with {self.app.config.backend_url}...")
+
+        logger.info(f"Login attempt for user: {username}")
+
+        # Create credentials
+        credentials = LoginCredentials(username=username, password=password)
+
+        # Call login through app
+        if hasattr(self.app, 'autobots_client'):
+            success, tokens, message = self.app.autobots_client.login(credentials)
+
+            if success and tokens:
+                status_widget.update("> Login successful!")
+                status_widget.styles.color = "green"
+                logger.info(f"Login successful for user: {username}")
+
+                # Save tokens
+                if hasattr(self.app, 'token_manager'):
+                    self.app.token_manager.save_tokens(tokens)
+
+                # Share token with kiwi CLI session and start it
+                self.app._kiwi_token = tokens.access_token
+                self.app._start_kiwi_session()
+
+                # Notify app of successful login
+                self.app.post_message(LoginSuccess(tokens))
+
+                # Switch to dashboard
+                self.app.switch_screen("dashboard")
+            else:
+                error_msg = f"~ {message}"
+                status_widget.update(error_msg)
+                status_widget.styles.color = "red"
+                logger.error(f"Login failed for user {username}: {message}")
+                password_input.value = ""
+                password_input.focus()
+        else:
+            error_msg = "~ Client not initialized"
+            status_widget.update(error_msg)
+            status_widget.styles.color = "red"
+            logger.error("Autobots client not found in app")
+
+    def action_quit(self) -> None:
+        """Quit the application."""
+        logger.info("Quitting application from login screen")
+        self.app.exit()
+
+
+class LoginSuccess(Message):
+    """Message sent when login is successful."""
+
+    bubbles = True
+
+    def __init__(self, tokens):
+        """Initialize login success message.
+
+        Args:
+            tokens: Authentication tokens
+        """
+        super().__init__()
+        self.tokens = tokens

kiwi_tui/screens/runtime_logs.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import os
+import signal
+
+from rich.text import Text
+from textual.screen import Screen
+from textual.widgets import Footer, Header, RichLog, Static
+from loguru import logger
+
+
+class RuntimeLogsScreen(Screen):
+    """Viewer for the persistent kiwi runtime process.
+
+    The kiwi runtime runs independently of the TUI (survives restarts).
+    This screen displays buffered log output from the runtime log file.
+    """
+
+    BINDINGS = [
+        ("escape", "go_back", "Back"),
+    ]
+
+    CSS = """
+    RuntimeLogsScreen {
+        background: $surface;
+    }
+
+    #runtime-log {
+        height: 1fr;
+        width: 100%;
+        scrollbar-size: 1 1;
+    }
+
+    #runtime-log-missing {
+        padding: 2 4;
+        color: #ff5555;
+    }
+    """
+
+    def compose(self):
+        yield Header()
+        has_runtime = getattr(self.app, "_kiwi_pid", None) is not None
+        if not has_runtime:
+            yield Static(
+                "No runtime session active.\n\n"
+                "Kiwi runtime not started.\n"
+                "Login first to auto-start the terminal agent,\n"
+                "or run: kiwi-runtime connect --server app",
+                id="runtime-log-missing",
+            )
+        else:
+            yield RichLog(id="runtime-log", wrap=True, markup=False)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        has_runtime = getattr(self.app, "_kiwi_pid", None) is not None
+        if has_runtime:
+            self._replay_buffer()
+            self.set_interval(0.1, self._poll_kiwi_lines)
+
+    def action_go_back(self) -> None:
+        """Go back without affecting the runtime process."""
+        self.app.pop_screen()
+
+    # ------------------------------------------------------------------
+    # Kiwi log output display
+    # ------------------------------------------------------------------
+
+    def _replay_buffer(self) -> None:
+        """Write all buffered lines to the RichLog widget."""
+        try:
+            log = self.query_one("#runtime-log", RichLog)
+        except Exception:
+            return
+        lines = list(self.app._kiwi_log_lines)
+        for line in lines:
+            log.write(Text.from_ansi(line))
+        self._lines_displayed = len(self.app._kiwi_log_lines)
+
+    def _poll_kiwi_lines(self) -> None:
+        """Display any new lines that arrived since last poll."""
+        total = len(self.app._kiwi_log_lines)
+        if total <= self._lines_displayed:
+            return
+        try:
+            log = self.query_one("#runtime-log", RichLog)
+        except Exception:
+            return
+        all_lines = list(self.app._kiwi_log_lines)
+        if self._lines_displayed >= total:
+            self._lines_displayed = total
+            return
+        new_lines = all_lines[-(total - self._lines_displayed):]
+        for line in new_lines:
+            log.write(Text.from_ansi(line))
+        self._lines_displayed = total

kiwi_tui/widgets.py

@@ -0,0 +1,197 @@
+"""Reusable widgets for Autobots TUI."""
+
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical, Horizontal
+from textual.widgets import Static, Button, Label, DataTable
+from textual.reactive import reactive
+from rich.text import Text
+
+
+class StatusBadge(Static):
+    """A colored status badge widget."""
+
+    DEFAULT_CSS = """
+    StatusBadge {
+        width: auto;
+        height: 1;
+        padding: 0 1;
+        margin: 0 1;
+    }
+
+    StatusBadge.success {
+        background: $success;
+        color: $text;
+    }
+
+    StatusBadge.error {
+        background: $error;
+        color: $text;
+    }
+
+    StatusBadge.warning {
+        background: $warning;
+        color: $text;
+    }
+
+    StatusBadge.info {
+        background: $accent;
+        color: $text;
+    }
+    """
+
+    def __init__(self, label: str, variant: str = "info", **kwargs):
+        """Initialize status badge.
+
+        Args:
+            label: Text to display
+            variant: Color variant (success, error, warning, info)
+        """
+        super().__init__(label, **kwargs)
+        self.add_class(variant)
+
+
+class StatCard(Container):
+    """A card displaying a statistic."""
+
+    DEFAULT_CSS = """
+    StatCard {
+        width: 1fr;
+        height: auto;
+        border: none;
+        padding: 0;
+        margin: 0 2;
+    }
+
+    StatCard > .stat-value {
+        text-align: left;
+        text-style: bold;
+        color: #5fffff;
+    }
+
+    StatCard > .stat-label {
+        text-align: left;
+        color: $text-muted;
+    }
+    """
+
+    value: reactive[str] = reactive("", init=False)
+    label: reactive[str] = reactive("", init=False)
+
+    def __init__(self, label: str, value: str = "0", **kwargs):
+        """Initialize stat card.
+
+        Args:
+            label: Description of the stat
+            value: Current value
+        """
+        super().__init__(**kwargs)
+        self._initial_label = label
+        self._initial_value = value
+
+    def compose(self) -> ComposeResult:
+        """Compose stat card widgets."""
+        yield Static(self._initial_value, classes="stat-value")
+        yield Static(self._initial_label, classes="stat-label")
+
+    def on_mount(self) -> None:
+        """Called when widget is mounted."""
+        self.label = self._initial_label
+        self.value = self._initial_value
+
+    def watch_value(self, value: str) -> None:
+        """Update displayed value."""
+        if self.is_mounted:
+            self.query_one(".stat-value", Static).update(value)
+
+    def watch_label(self, label: str) -> None:
+        """Update displayed label."""
+        if self.is_mounted:
+            self.query_one(".stat-label", Static).update(label)
+
+
+class ActionButton(Button):
+    """A styled action button."""
+
+    DEFAULT_CSS = """
+    ActionButton {
+        min-width: 16;
+        margin: 0 1;
+        border: none;
+        background: $surface;
+        color: $text;
+    }
+
+    ActionButton:focus {
+        background: #5fffff;
+        color: black;
+    }
+
+    ActionButton.primary {
+        color: #5fffff;
+    }
+
+    ActionButton.success {
+        color: $success;
+    }
+
+    ActionButton.danger {
+        color: $error;
+    }
+    """
+
+    def __init__(self, label: str, variant: str = "primary", **kwargs):
+        """Initialize action button.
+
+        Args:
+            label: Button text
+            variant: Style variant (primary, success, danger)
+        """
+        super().__init__(label, **kwargs)
+        self.add_class(variant)
+
+
+class InfoPanel(Container):
+    """An information panel with title and content."""
+
+    DEFAULT_CSS = """
+    InfoPanel {
+        height: auto;
+        border: none;
+        padding: 0;
+        margin: 1 0;
+    }
+
+    InfoPanel > .panel-title {
+        text-style: bold;
+        color: #5fffff;
+        margin-bottom: 0;
+    }
+
+    InfoPanel > .panel-content {
+        color: $text;
+    }
+    """
+
+    def __init__(self, title: str, content: str = "", **kwargs):
+        """Initialize info panel.
+
+        Args:
+            title: Panel title
+            content: Panel content
+        """
+        super().__init__(**kwargs)
+        self._title = title
+        self._content = content
+
+    def compose(self) -> ComposeResult:
+        """Compose info panel widgets."""
+        yield Static(self._title, classes="panel-title")
+        yield Static(self._content, classes="panel-content")
+
+    def update_content(self, content: str) -> None:
+        """Update panel content.
+
+        Args:
+            content: New content to display
+        """
+        self.query_one(".panel-content", Static).update(content)