clue2app-cli 0.2.7__py3-none-any.whl

clue2app_cli/tui/curses_app.py

@@ -0,0 +1,733 @@
+"""ncurses-based TUI for Clue2App CLI.
+
+Provides a traditional terminal interface using ncurses for systems
+without Textual support or minimal terminal environments.
+"""
+
+import curses
+import sys
+from typing import Optional, List, Callable
+from enum import Enum
+
+from .data import DataProvider, AppInfo, ProjectInfo, AppStatus, BuildStatus
+
+
+class Screen(Enum):
+    """Available screens."""
+    APPS = "apps"
+    DETAILS = "details"
+    LOGS = "logs"
+    PROJECTS = "projects"
+    HELP = "help"
+    CONFIRM = "confirm"
+    STATUS_LOG = "status_log"
+
+
+class Colors:
+    """Color pair indices."""
+    NORMAL = 0
+    GREEN = 1
+    RED = 2
+    YELLOW = 3
+    CYAN = 4
+    HEADER = 5
+    SELECTED = 6
+    WHITE = 7
+
+
+class CursesTUI:
+    """ncurses-based interactive TUI."""
+
+    def __init__(self, stdscr, initial_screen: str = 'apps'):
+        self.stdscr = stdscr
+        self.data_provider = DataProvider()
+
+        self.current_screen = Screen.APPS if initial_screen == 'apps' else Screen.PROJECTS
+        self.selected_index = 0
+        self.scroll_offset = 0
+
+        self.apps: List[AppInfo] = []
+        self.projects: List[ProjectInfo] = []
+        self.selected_app: Optional[AppInfo] = None
+        self.show_unlinked = False
+        self.show_all = False  # False = show only current project
+        self._current_project: Optional[ProjectInfo] = self.data_provider.get_current_project()
+
+        self.logs_content = ""
+        self.confirm_message = ""
+        self.confirm_callback: Optional[Callable] = None
+
+        # Status log for displaying messages/errors
+        self._status_messages: List[tuple] = []  # [(timestamp, level, message), ...]
+        self._max_messages = 50
+
+        self._init_colors()
+
+    def _init_colors(self) -> None:
+        """Initialize color pairs."""
+        curses.start_color()
+        curses.use_default_colors()
+
+        curses.init_pair(Colors.GREEN, curses.COLOR_GREEN, -1)
+        curses.init_pair(Colors.RED, curses.COLOR_RED, -1)
+        curses.init_pair(Colors.YELLOW, curses.COLOR_YELLOW, -1)
+        curses.init_pair(Colors.CYAN, curses.COLOR_CYAN, -1)
+        curses.init_pair(Colors.HEADER, curses.COLOR_BLACK, curses.COLOR_CYAN)
+        curses.init_pair(Colors.SELECTED, curses.COLOR_BLACK, curses.COLOR_WHITE)
+        curses.init_pair(Colors.WHITE, curses.COLOR_WHITE, -1)
+
+    def _log(self, message: str, level: str = "info") -> None:
+        """Add a message to the status log.
+
+        Args:
+            message: The message to log
+            level: One of "info", "warn", "error"
+        """
+        from datetime import datetime
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        full_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self._status_messages.append((timestamp, level, message))
+        # Keep only the last N messages
+        if len(self._status_messages) > self._max_messages:
+            self._status_messages = self._status_messages[-self._max_messages:]
+
+        # Also write to file for easy access
+        try:
+            with open("/tmp/c2a_tui.log", "a") as f:
+                f.write(f"[{full_timestamp}] [{level.upper()}] {message}\n")
+        except:
+            pass
+
+    def run(self) -> None:
+        """Main event loop."""
+        curses.curs_set(0)  # Hide cursor
+        self.stdscr.keypad(True)
+        self.stdscr.timeout(1000)  # 1s timeout - only redraw on input or timeout
+
+        # Initial data load
+        self._load_data()
+
+        running = True
+        needs_redraw = True
+        while running:
+            if needs_redraw:
+                self._draw()
+                self.stdscr.refresh()
+                needs_redraw = False
+
+            result = self._handle_input()
+            if result is False:
+                running = False
+            elif result is True:
+                needs_redraw = True  # Input received, redraw
+
+    def _load_data(self) -> None:
+        """Load data for current screen."""
+        try:
+            if self.current_screen == Screen.APPS:
+                # Determine project filter
+                project_id = None
+                if self._current_project and not self.show_all:
+                    project_id = self._current_project.id
+                self.apps = self.data_provider.get_apps(
+                    project_id=project_id,
+                    include_unlinked=self.show_unlinked
+                )
+                self._log(f"Loaded {len(self.apps)} apps", "info")
+            elif self.current_screen == Screen.PROJECTS:
+                self.projects = self.data_provider.get_projects()
+                self._log(f"Loaded {len(self.projects)} projects", "info")
+            elif self.current_screen == Screen.LOGS and self.selected_app:
+                self.logs_content = self.data_provider.get_logs(self.selected_app.name, lines=100)
+                self._log(f"Loaded logs for {self.selected_app.display_name}", "info")
+        except Exception as e:
+            error_msg = str(e)
+            # Extract useful info from common errors
+            if "500" in error_msg:
+                self._log(f"Server Error (500): API request failed", "error")
+            elif "401" in error_msg or "403" in error_msg:
+                self._log(f"Auth Error: Please re-login", "error")
+            elif "Connection" in error_msg or "timeout" in error_msg.lower():
+                self._log(f"Network Error: Cannot reach server", "error")
+            else:
+                self._log(f"Error: {error_msg[:60]}", "error")
+            self._show_error(str(e))
+
+    def _draw(self) -> None:
+        """Draw the current screen."""
+        self.stdscr.clear()
+        height, width = self.stdscr.getmaxyx()
+
+        # Draw header
+        self._draw_header(width)
+
+        # Draw main content based on screen
+        if self.current_screen == Screen.APPS:
+            self._draw_apps_screen(height, width)
+        elif self.current_screen == Screen.DETAILS:
+            self._draw_details_screen(height, width)
+        elif self.current_screen == Screen.LOGS:
+            self._draw_logs_screen(height, width)
+        elif self.current_screen == Screen.PROJECTS:
+            self._draw_projects_screen(height, width)
+        elif self.current_screen == Screen.HELP:
+            self._draw_help_screen(height, width)
+        elif self.current_screen == Screen.CONFIRM:
+            self._draw_confirm_screen(height, width)
+        elif self.current_screen == Screen.STATUS_LOG:
+            self._draw_status_log_screen(height, width)
+
+        # Draw footer
+        self._draw_footer(height, width)
+
+        self.stdscr.refresh()
+
+    def _draw_header(self, width: int) -> None:
+        """Draw the header bar."""
+        header = " Clue2App TUI "
+        project = self.data_provider.get_current_project()
+        if project:
+            header += f"| Project: {project.name} "
+
+        header = header.ljust(width)
+        self.stdscr.attron(curses.color_pair(Colors.HEADER) | curses.A_BOLD)
+        self.stdscr.addstr(0, 0, header[:width-1])
+        self.stdscr.attroff(curses.color_pair(Colors.HEADER) | curses.A_BOLD)
+
+    def _draw_footer(self, height: int, width: int) -> None:
+        """Draw the footer with shortcuts and status log."""
+        # Draw status log line (above footer)
+        if self._status_messages:
+            timestamp, level, message = self._status_messages[-1]
+            status_line = f"[{timestamp}] {message}"
+
+            # Choose color based on level
+            if level == "error":
+                color = curses.color_pair(Colors.RED)
+            elif level == "warn":
+                color = curses.color_pair(Colors.YELLOW)
+            else:
+                color = curses.color_pair(Colors.CYAN)
+
+            try:
+                self.stdscr.attron(color)
+                self.stdscr.addstr(height - 2, 0, status_line[:width-1].ljust(width-1))
+                self.stdscr.attroff(color)
+            except curses.error:
+                pass
+
+        # Draw shortcuts footer
+        shortcuts = {
+            Screen.APPS: "[↵]View [l]Logs [r]Rebuild [s]Start [p]Proj [a]All [L]Log [q]Quit",
+            Screen.DETAILS: "[l]Logs [r]Rebuild [o]URL [L]Log [q]Back",
+            Screen.LOGS: "[f]Follow [g]Top [G]End [L]Log [q]Back",
+            Screen.PROJECTS: "[↵]Select [R]Refresh [L]Log [q]Back",
+            Screen.HELP: "[q]Back",
+            Screen.CONFIRM: "[y]Yes [n]No",
+            Screen.STATUS_LOG: "[c]Clear [q]Back",
+        }
+
+        footer = shortcuts.get(self.current_screen, "[q]Back")
+        footer = footer.center(width)
+
+        self.stdscr.attron(curses.color_pair(Colors.HEADER))
+        try:
+            self.stdscr.addstr(height - 1, 0, footer[:width-1])
+        except curses.error:
+            pass
+        self.stdscr.attroff(curses.color_pair(Colors.HEADER))
+
+    def _draw_apps_screen(self, height: int, width: int) -> None:
+        """Draw the apps list screen."""
+        # Column headers
+        self.stdscr.attron(curses.A_BOLD)
+        header = f"{'NAME':<25} {'PROJECT':<15} {'BUILD':<12} {'RUNTIME':<15} {'PODS':<5}"
+        self.stdscr.addstr(2, 2, header[:width-4])
+        self.stdscr.attroff(curses.A_BOLD)
+
+        # Separator
+        self.stdscr.addstr(3, 2, "─" * min(width - 4, 80))
+
+        # Apps list
+        visible_rows = height - 6
+        start_idx = self.scroll_offset
+        end_idx = min(start_idx + visible_rows, len(self.apps))
+
+        for i, app in enumerate(self.apps[start_idx:end_idx]):
+            row = 4 + i
+            is_selected = (start_idx + i) == self.selected_index
+
+            # Format columns
+            project_name = app.project_name or "(unlinked)"
+            build_symbol = self._status_symbol(app.build_status)
+            build_text = app.build_status.value[:8]
+            runtime_text = app.runtime_status.value[:12]
+
+            # Determine runtime status color
+            if app.runtime_status == AppStatus.RUNNING:
+                runtime_color = Colors.GREEN
+            elif app.runtime_status == AppStatus.SCALED_TO_ZERO:
+                runtime_color = Colors.YELLOW
+            elif app.runtime_status in (AppStatus.STOPPED, AppStatus.FAILED):
+                runtime_color = Colors.RED
+            else:
+                runtime_color = Colors.WHITE
+
+            if is_selected:
+                # Selected row - use selection color for everything
+                self.stdscr.attron(curses.color_pair(Colors.SELECTED))
+                line = f"{app.display_name:<25} {project_name:<15} {build_symbol} {build_text:<10} {runtime_text:<15} {app.pod_count:<5}"
+                self.stdscr.addstr(row, 2, line[:width-4])
+                self.stdscr.attroff(curses.color_pair(Colors.SELECTED))
+            else:
+                # Render columns separately with colors
+                col = 2
+                # Name
+                self.stdscr.addstr(row, col, f"{app.display_name:<25}")
+                col += 25
+                # Project
+                self.stdscr.addstr(row, col, f"{project_name:<15}")
+                col += 15 + 1
+                # Build status with symbol
+                self.stdscr.addstr(row, col, f"{build_symbol} {build_text:<10}")
+                col += 12
+                # Runtime status with color
+                self.stdscr.attron(curses.color_pair(runtime_color))
+                self.stdscr.addstr(row, col, f"{runtime_text:<15}")
+                self.stdscr.attroff(curses.color_pair(runtime_color))
+                col += 15
+                # Pod count
+                self.stdscr.addstr(row, col, f"{app.pod_count:<5}")
+
+        # Show scroll indicator if needed
+        if len(self.apps) > visible_rows:
+            scroll_info = f"[{self.selected_index + 1}/{len(self.apps)}]"
+            self.stdscr.addstr(2, width - len(scroll_info) - 2, scroll_info)
+
+    def _draw_details_screen(self, height: int, width: int) -> None:
+        """Draw app details screen."""
+        if not self.selected_app:
+            return
+
+        app = self.selected_app
+        row = 2
+
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(row, 2, f"App Details: {app.display_name}")
+        self.stdscr.attroff(curses.A_BOLD)
+        row += 2
+
+        details = [
+            ("Name", app.name),
+            ("Namespace", app.namespace),
+            ("Project", app.project_name or "(unlinked)"),
+            ("", ""),
+            ("Build Status", app.build_status.value),
+            ("Build Count", str(app.build_count)),
+            ("Build Reason", app.build_reason or "N/A"),
+            ("Stack", app.stack or "N/A"),
+            ("", ""),
+            ("Git URL", app.git_url or "N/A"),
+            ("Git Revision", app.git_revision or "N/A"),
+            ("", ""),
+            ("Runtime Status", app.runtime_status.value),
+            ("Pods", str(app.pod_count)),
+            ("URL", app.url or "N/A"),
+        ]
+
+        for label, value in details:
+            if label:
+                self.stdscr.attron(curses.color_pair(Colors.CYAN))
+                self.stdscr.addstr(row, 2, f"{label}:")
+                self.stdscr.attroff(curses.color_pair(Colors.CYAN))
+                self.stdscr.addstr(row, 18, str(value)[:width-20])
+            row += 1
+            if row >= height - 2:
+                break
+
+    def _draw_logs_screen(self, height: int, width: int) -> None:
+        """Draw logs screen."""
+        if not self.selected_app:
+            return
+
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(2, 2, f"Logs: {self.selected_app.display_name}")
+        self.stdscr.attroff(curses.A_BOLD)
+
+        # Display logs
+        lines = self.logs_content.split('\n') if self.logs_content else ["No logs available"]
+        visible_rows = height - 5
+
+        start_line = max(0, len(lines) - visible_rows - self.scroll_offset)
+        end_line = start_line + visible_rows
+
+        for i, line in enumerate(lines[start_line:end_line]):
+            row = 4 + i
+            if row < height - 1:
+                self.stdscr.addstr(row, 2, line[:width-4])
+
+    def _draw_projects_screen(self, height: int, width: int) -> None:
+        """Draw projects list screen."""
+        self.stdscr.attron(curses.A_BOLD)
+        header = f"{'NAME':<30} {'ID':<40}"
+        self.stdscr.addstr(2, 2, header[:width-4])
+        self.stdscr.attroff(curses.A_BOLD)
+
+        self.stdscr.addstr(3, 2, "─" * min(width - 4, 80))
+
+        visible_rows = height - 6
+
+        for i, project in enumerate(self.projects[:visible_rows]):
+            row = 4 + i
+            is_selected = i == self.selected_index
+
+            if is_selected:
+                self.stdscr.attron(curses.color_pair(Colors.SELECTED))
+
+            line = f"{project.name:<30} {project.id:<40}"
+            self.stdscr.addstr(row, 2, line[:width-4])
+
+            if is_selected:
+                self.stdscr.attroff(curses.color_pair(Colors.SELECTED))
+
+    def _draw_help_screen(self, height: int, width: int) -> None:
+        """Draw help screen."""
+        help_text = [
+            "Clue2App TUI - Keyboard Shortcuts",
+            "",
+            "Navigation:",
+            "  j / ↓       Move down",
+            "  k / ↑       Move up",
+            "  Enter       Select / View details",
+            "  q / Escape  Back / Quit",
+            "",
+            "Apps Screen:",
+            "  l           View app logs",
+            "  r           Rebuild app",
+            "  d           Delete app",
+            "  p           Switch to projects",
+            "  a           Toggle all/current project",
+            "  u           Toggle unlinked apps",
+            "  R           Refresh",
+            "  L           View status log",
+            "",
+            "Logs Screen:",
+            "  f           Toggle follow mode",
+            "  g           Scroll to top",
+            "  G           Scroll to bottom",
+            "",
+            "Status Log:",
+            "  c           Clear log messages",
+            "",
+            "Press q to close this help.",
+        ]
+
+        for i, line in enumerate(help_text):
+            if i + 2 < height - 1:
+                self.stdscr.addstr(i + 2, 2, line[:width-4])
+
+    def _draw_status_log_screen(self, height: int, width: int) -> None:
+        """Draw status log screen showing all messages."""
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(2, 2, "Status Log (most recent at bottom)")
+        self.stdscr.attroff(curses.A_BOLD)
+        self.stdscr.addstr(3, 2, "─" * min(width - 4, 80))
+
+        visible_rows = height - 7  # Leave room for header, title, and footer
+        messages = self._status_messages[-visible_rows:] if self._status_messages else []
+
+        for i, (timestamp, level, message) in enumerate(messages):
+            row = 4 + i
+            if row >= height - 3:
+                break
+
+            # Choose color based on level
+            if level == "error":
+                color = curses.color_pair(Colors.RED)
+            elif level == "warn":
+                color = curses.color_pair(Colors.YELLOW)
+            else:
+                color = curses.color_pair(Colors.CYAN)
+
+            line = f"[{timestamp}] {message}"
+            try:
+                self.stdscr.attron(color)
+                self.stdscr.addstr(row, 2, line[:width-4])
+                self.stdscr.attroff(color)
+            except curses.error:
+                pass
+
+        if not messages:
+            self.stdscr.addstr(5, 2, "(No messages yet)", curses.A_DIM)
+
+    def _draw_confirm_screen(self, height: int, width: int) -> None:
+        """Draw confirmation dialog."""
+        # Center the dialog
+        dialog_width = 50
+        dialog_height = 5
+        start_y = (height - dialog_height) // 2
+        start_x = (width - dialog_width) // 2
+
+        # Draw border
+        for i in range(dialog_height):
+            self.stdscr.addstr(start_y + i, start_x, " " * dialog_width, curses.color_pair(Colors.HEADER))
+
+        # Draw message
+        self.stdscr.attron(curses.A_BOLD)
+        msg = self.confirm_message[:dialog_width - 4]
+        self.stdscr.addstr(start_y + 1, start_x + 2, msg.center(dialog_width - 4))
+        self.stdscr.attroff(curses.A_BOLD)
+
+        # Draw options
+        self.stdscr.addstr(start_y + 3, start_x + 2, "[y] Yes    [n] No".center(dialog_width - 4))
+
+    def _handle_input(self):
+        """Handle keyboard input. Returns False to exit, None for no input, True for redraw."""
+        try:
+            key = self.stdscr.getch()
+        except:
+            return None
+
+        if key == -1:  # No input (timeout)
+            return None
+
+        # Global keys
+        if key == ord('q') or key == 27:  # q or Escape
+            if self.current_screen in (Screen.APPS,):
+                return False  # Exit app
+            else:
+                self._go_back()
+                return True
+
+        # Screen-specific handlers
+        if self.current_screen == Screen.APPS:
+            return self._handle_apps_input(key)
+        elif self.current_screen == Screen.DETAILS:
+            return self._handle_details_input(key)
+        elif self.current_screen == Screen.LOGS:
+            return self._handle_logs_input(key)
+        elif self.current_screen == Screen.PROJECTS:
+            return self._handle_projects_input(key)
+        elif self.current_screen == Screen.HELP:
+            return self._handle_help_input(key)
+        elif self.current_screen == Screen.CONFIRM:
+            return self._handle_confirm_input(key)
+        elif self.current_screen == Screen.STATUS_LOG:
+            return self._handle_status_log_input(key)
+
+        return True
+
+    def _handle_apps_input(self, key: int) -> bool:
+        """Handle input on apps screen."""
+        if key == ord('j') or key == curses.KEY_DOWN:
+            self.selected_index = min(self.selected_index + 1, len(self.apps) - 1)
+            self._adjust_scroll()
+        elif key == ord('k') or key == curses.KEY_UP:
+            self.selected_index = max(self.selected_index - 1, 0)
+            self._adjust_scroll()
+        elif key == ord('\n') or key == curses.KEY_ENTER or key == 10:
+            if self.apps:
+                self.selected_app = self.apps[self.selected_index]
+                self.current_screen = Screen.DETAILS
+        elif key == ord('l'):
+            if self.apps:
+                self.selected_app = self.apps[self.selected_index]
+                self.scroll_offset = 0
+                self._load_data()
+                self.current_screen = Screen.LOGS
+        elif key == ord('r'):
+            if self.apps:
+                self.selected_app = self.apps[self.selected_index]
+                self.confirm_message = f"Rebuild {self.selected_app.display_name}?"
+                self.confirm_callback = self._do_rebuild
+                self.current_screen = Screen.CONFIRM
+        elif key == ord('s'):
+            if self.apps:
+                self.selected_app = self.apps[self.selected_index]
+                self.confirm_message = f"Start/Restart {self.selected_app.display_name}?"
+                self.confirm_callback = self._do_restart
+                self.current_screen = Screen.CONFIRM
+        elif key == ord('d'):
+            if self.apps:
+                self.selected_app = self.apps[self.selected_index]
+                self.confirm_message = f"Delete {self.selected_app.display_name}?"
+                self.confirm_callback = self._do_delete
+                self.current_screen = Screen.CONFIRM
+        elif key == ord('p'):
+            self.selected_index = 0
+            self.current_screen = Screen.PROJECTS
+            self._load_data()
+        elif key == ord('u'):
+            self.show_unlinked = not self.show_unlinked
+            self.selected_index = 0
+            self._load_data()
+        elif key == ord('a'):
+            if self._current_project:
+                self.show_all = not self.show_all
+                self.selected_index = 0
+                self._load_data()
+        elif key == ord('R'):
+            self._load_data()
+        elif key == ord('?'):
+            self.current_screen = Screen.HELP
+        elif key == ord('L'):
+            self.current_screen = Screen.STATUS_LOG
+
+        return True
+
+    def _handle_details_input(self, key: int) -> bool:
+        """Handle input on details screen."""
+        if key == ord('l'):
+            self.scroll_offset = 0
+            self.current_screen = Screen.LOGS
+            self._load_data()
+        elif key == ord('r'):
+            self.confirm_message = f"Rebuild {self.selected_app.display_name}?"
+            self.confirm_callback = self._do_rebuild
+            self.current_screen = Screen.CONFIRM
+        elif key == ord('o'):
+            if self.selected_app and self.selected_app.url:
+                import webbrowser
+                webbrowser.open(self.selected_app.url)
+        elif key == ord('L'):
+            self.current_screen = Screen.STATUS_LOG
+
+        return True
+
+    def _handle_logs_input(self, key: int) -> bool:
+        """Handle input on logs screen."""
+        if key == ord('g'):
+            self.scroll_offset = 0
+        elif key == ord('G'):
+            lines = self.logs_content.split('\n') if self.logs_content else []
+            height, _ = self.stdscr.getmaxyx()
+            visible = height - 5
+            self.scroll_offset = max(0, len(lines) - visible)
+        elif key == ord('R'):
+            self._load_data()
+        elif key == ord('L'):
+            self.current_screen = Screen.STATUS_LOG
+
+        return True
+
+    def _handle_projects_input(self, key: int) -> bool:
+        """Handle input on projects screen."""
+        if key == ord('j') or key == curses.KEY_DOWN:
+            self.selected_index = min(self.selected_index + 1, len(self.projects) - 1)
+        elif key == ord('k') or key == curses.KEY_UP:
+            self.selected_index = max(self.selected_index - 1, 0)
+        elif key == ord('\n') or key == curses.KEY_ENTER or key == 10:
+            if self.projects and self.selected_index < len(self.projects):
+                # Set the selected project as current
+                selected_project = self.projects[self.selected_index]
+                self._current_project = selected_project
+                self.show_all = False  # Reset to show only this project's apps
+                self._log(f"Switched to project: {selected_project.name}", "info")
+                # Go back to apps screen and reload
+                self.current_screen = Screen.APPS
+                self.selected_index = 0
+                self.scroll_offset = 0
+                self._load_data()
+        elif key == ord('R'):
+            self._load_data()
+        elif key == ord('L'):
+            self.current_screen = Screen.STATUS_LOG
+
+        return True
+
+    def _handle_help_input(self, key: int) -> bool:
+        """Handle input on help screen."""
+        # Any key returns to previous screen
+        return True
+
+    def _handle_confirm_input(self, key: int) -> bool:
+        """Handle input on confirm screen."""
+        if key == ord('y') or key == ord('Y'):
+            if self.confirm_callback:
+                self.confirm_callback()
+            self._go_back()
+        elif key == ord('n') or key == ord('N'):
+            self._go_back()
+
+        return True
+
+    def _handle_status_log_input(self, key: int) -> bool:
+        """Handle input on status log screen."""
+        if key == ord('c') or key == ord('C'):
+            # Clear log messages
+            self._status_messages = []
+            self._log("Log cleared", "info")
+        # Any other key (including q/Escape handled globally) does nothing special
+        return True
+
+    def _go_back(self) -> None:
+        """Go back to previous screen."""
+        self.current_screen = Screen.APPS
+        self.selected_index = 0
+        self.scroll_offset = 0
+        self._load_data()
+
+    def _adjust_scroll(self) -> None:
+        """Adjust scroll offset to keep selection visible."""
+        height, _ = self.stdscr.getmaxyx()
+        visible_rows = height - 6
+
+        if self.selected_index < self.scroll_offset:
+            self.scroll_offset = self.selected_index
+        elif self.selected_index >= self.scroll_offset + visible_rows:
+            self.scroll_offset = self.selected_index - visible_rows + 1
+
+    def _status_symbol(self, status: BuildStatus) -> str:
+        """Get symbol for build status."""
+        symbols = {
+            BuildStatus.READY: "✓",
+            BuildStatus.BUILDING: "⟳",
+            BuildStatus.FAILED: "✗",
+            BuildStatus.UNKNOWN: "?",
+        }
+        return symbols.get(status, "?")
+
+    def _do_rebuild(self) -> None:
+        """Execute rebuild."""
+        if self.selected_app:
+            self.data_provider.rebuild_app(self.selected_app.name)
+            self._load_data()
+
+    def _do_delete(self) -> None:
+        """Execute delete."""
+        if self.selected_app:
+            self.data_provider.delete_app(self.selected_app.name)
+            self._load_data()
+
+    def _do_restart(self) -> None:
+        """Execute restart/start service."""
+        if self.selected_app:
+            result = self.data_provider.restart_service(
+                self.selected_app.name,
+                namespace=self.selected_app.namespace
+            )
+            if result.get("success"):
+                self._log(f"Started {self.selected_app.display_name}", "info")
+            else:
+                error = result.get("error", "Unknown error")
+                self._log(f"Failed to start {self.selected_app.display_name}: {error}", "error")
+            self._load_data()
+
+    def _show_error(self, message: str) -> None:
+        """Show error message and add to status log."""
+        # Add to status log
+        self._log(f"Error: {message[:100]}", "error")
+        # Also display on screen
+        try:
+            self.stdscr.addstr(1, 2, f"Error: {message[:60]}", curses.color_pair(Colors.RED))
+        except curses.error:
+            pass
+
+
+def run_curses_tui(initial_screen: str = 'apps') -> None:
+    """Run the ncurses TUI."""
+    def main(stdscr):
+        tui = CursesTUI(stdscr, initial_screen=initial_screen)
+        tui.run()
+
+    curses.wrapper(main)