Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
28.0 KB
Raw Blame
"""Welcome screen for OpenRAG TUI."""

import os
from pathlib import Path

from dotenv import load_dotenv
from rich.text import Text
from textual.app import ComposeResult
from textual.containers import Container, Horizontal, Vertical
from textual.screen import Screen
from textual.widgets import Button, Footer, Static

from .. import __version__
from ..managers.container_manager import (
    ContainerManager,
    ServiceStatus,
    format_port_conflict_message,
)
from ..managers.docling_manager import DoclingManager
from ..managers.env_manager import EnvManager
from ..widgets.command_modal import CommandOutputModal
from ..widgets.version_mismatch_warning_modal import VersionMismatchWarningModal


class WelcomeScreen(Screen):
    """Initial welcome screen with setup options."""

    BINDINGS = [
        ("q", "quit", "Quit"),
        ("r", "refresh", "Refresh"),
    ]

    def __init__(self):
        super().__init__()
        self.container_manager = ContainerManager()
        self.env_manager = EnvManager()
        self.docling_manager = DoclingManager()
        self.services_running = False
        self.docling_running = False
        self.has_oauth_config = False
        self.default_button_id = "basic-setup-btn"
        self._state_checked = False
        self.has_flow_backups = False

        # Check if .env file exists
        self.has_env_file = self.env_manager.env_file.exists()

        # Load .env file if it exists
        # override=True ensures .env file values take precedence over existing environment variables
        load_dotenv(override=True)

        # Check OAuth config immediately
        self.has_oauth_config = bool(os.getenv("GOOGLE_OAUTH_CLIENT_ID")) or bool(
            os.getenv("MICROSOFT_GRAPH_OAUTH_CLIENT_ID")
        )

        # Check for flow backups
        self.has_flow_backups = self._check_flow_backups()

    def compose(self) -> ComposeResult:
        """Create the welcome screen layout."""
        # Try to detect services synchronously before creating buttons
        self._detect_services_sync()

        yield Container(
            Vertical(
                Static(self._create_welcome_text(), id="welcome-text"),
                self._create_dynamic_buttons(),
                id="welcome-container",
            ),
            id="main-container",
        )
        yield Footer()

    def _check_flow_backups(self) -> bool:
        """Check if there are any flow backups in flows/backup directory."""
        from ..managers.env_manager import EnvManager

        # Get flows path from env config
        env_manager = EnvManager()
        env_manager.load_existing_env()
        flows_path = Path(
            env_manager.config.openrag_flows_path.replace("$HOME", str(Path.home()))
        ).expanduser()
        backup_dir = flows_path / "backup"
        if not backup_dir.exists():
            return False

        try:
            # Check if there are any .json files in the backup directory
            backup_files = list(backup_dir.glob("*.json"))
            return len(backup_files) > 0
        except Exception:
            return False

    def _detect_services_sync(self) -> None:
        """Synchronously detect if services are running."""
        if not self.container_manager.is_available():
            self.services_running = False
            self.docling_running = self.docling_manager.is_running()
            return

        try:
            # Use detected runtime command to check services
            import subprocess

            compose_cmd = self.container_manager.runtime_info.compose_command + [
                "-f",
                str(self.container_manager.compose_file),
                "ps",
                "--format",
                "json",
            ]
            result = subprocess.run(compose_cmd, capture_output=True, text=True, timeout=5)

            if result.returncode == 0:
                import json

                services = []

                # Try parsing as a single JSON array first (podman format)
                try:
                    parsed = json.loads(result.stdout.strip())
                    if isinstance(parsed, list):
                        services = parsed
                    else:
                        services = [parsed] if isinstance(parsed, dict) else []
                except json.JSONDecodeError:
                    # Fallback: try parsing line-by-line (docker format)
                    for line in result.stdout.strip().split("\n"):
                        if line.strip():
                            try:
                                service = json.loads(line)
                                if isinstance(service, dict):
                                    services.append(service)
                            except json.JSONDecodeError:
                                continue

                # Check if services are running (exclude starting/created states)
                # State can be lowercase or mixed case, so normalize it
                # Only consider expected services (filter out stale/leftover containers)
                expected = set(self.container_manager.expected_services)
                name_map = self.container_manager.container_name_map
                running_services = set()
                starting_services = set()
                for s in services:
                    if not isinstance(s, dict):
                        continue
                    # Get service name - try compose label first (most reliable for Podman)
                    labels = s.get("Labels", {}) or {}
                    service_name = labels.get("com.docker.compose.service", "")
                    if not service_name:
                        # Fall back to container name mapping
                        container_name = s.get("Name") or s.get("Service", "")
                        if not container_name:
                            names = s.get("Names", [])
                            if names and isinstance(names, list):
                                container_name = names[0]
                        # Map container name to service name using container_name_map
                        service_name = name_map.get(container_name, container_name)
                    # Skip if not an expected service
                    if service_name not in expected:
                        continue
                    state = str(s.get("State", "")).lower()
                    if state == "running":
                        running_services.add(service_name)
                    elif "starting" in state or "created" in state:
                        starting_services.add(service_name)

                # Services are running if all expected services are in running state
                # (i.e., we have all expected services running and none are still starting)
                self.services_running = (
                    len(running_services) == len(expected) and len(starting_services) == 0
                )
            else:
                self.services_running = False
        except Exception:
            # Fallback to False if detection fails
            self.services_running = False

        # Update native service state as part of detection
        self.docling_running = self.docling_manager.is_running()

    def _create_welcome_text(self) -> Text:
        """Create a minimal welcome message."""
        welcome_text = Text()
        ascii_art = """
██████╗ ██████╗ ███████╗███╗   ██╗██████╗  █████╗  ██████╗ 
██╔═══██╗██╔══██╗██╔════╝████╗  ██║██╔══██╗██╔══██╗██╔════╝ 
██║   ██║██████╔╝█████╗  ██╔██╗ ██║██████╔╝███████║██║  ███╗
██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║██╔══██╗██╔══██║██║   ██║
╚██████╔╝██║     ███████╗██║ ╚████║██║  ██║██║  ██║╚██████╔╝
╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝  ╚═╝╚═════╝
"""
        welcome_text.append(ascii_art, style="bold white")
        welcome_text.append("Terminal User Interface for OpenRAG\n", style="dim")
        welcome_text.append(f"v{__version__}\n\n", style="white")

        # Check if all services are running
        all_services_running = self.services_running and self.docling_running

        if all_services_running:
            welcome_text.append("✓ All services are running\n\n", style="bold green")
        elif self.services_running or self.docling_running:
            welcome_text.append("⚠ Some services are running\n\n", style="bold yellow")
        elif self.has_oauth_config:
            welcome_text.append(
                "OAuth credentials detected — Advanced Setup recommended\n\n",
                style="bold green",
            )
        else:
            welcome_text.append("Select a setup below to continue\n\n", style="white")
        return welcome_text

    def _create_dynamic_buttons(self) -> Horizontal:
        """Create buttons based on current state."""
        # Check OAuth config early to determine which buttons to show
        has_oauth = bool(os.getenv("GOOGLE_OAUTH_CLIENT_ID")) or bool(
            os.getenv("MICROSOFT_GRAPH_OAUTH_CLIENT_ID")
        )

        buttons = []

        # If no .env file exists, only show setup buttons
        if not self.has_env_file:
            if has_oauth:
                # If OAuth is configured, only show advanced setup
                buttons.append(Button("Advanced Setup", variant="success", id="advanced-setup-btn"))
            else:
                # If no OAuth, show both options with basic as primary
                buttons.append(Button("Basic Setup", variant="success", id="basic-setup-btn"))
                buttons.append(Button("Advanced Setup", variant="default", id="advanced-setup-btn"))
            return Horizontal(*buttons, classes="button-row")

        # Check if all services (native + container) are running
        all_services_running = self.services_running and self.docling_running

        if all_services_running:
            # All services running - show app link first, then stop all
            buttons.append(Button("Launch OpenRAG", variant="success", id="open-app-btn"))
            buttons.append(Button("Stop All Services", variant="error", id="stop-all-services-btn"))
        else:
            # Some or no services running - show setup options and start all
            if has_oauth:
                # If OAuth is configured, only show advanced setup
                buttons.append(Button("Advanced Setup", variant="success", id="advanced-setup-btn"))
            else:
                # If no OAuth, show both options with basic as primary
                buttons.append(Button("Basic Setup", variant="success", id="basic-setup-btn"))
                buttons.append(Button("Advanced Setup", variant="default", id="advanced-setup-btn"))

            buttons.append(Button("Start OpenRAG", variant="primary", id="start-all-services-btn"))

        # Always show status option
        buttons.append(Button("Status", variant="default", id="status-btn"))

        return Horizontal(*buttons, classes="button-row")

    async def on_mount(self) -> None:
        """Initialize screen state when mounted."""
        # Check if services are running
        if self.container_manager.is_available():
            services = await self.container_manager.get_service_status()
            expected = set(self.container_manager.expected_services)
            running_services = [
                s.name for s in services.values() if s.status == ServiceStatus.RUNNING
            ]
            starting_services = [
                s.name for s in services.values() if s.status == ServiceStatus.STARTING
            ]
            # Services are running if all expected services are in running state
            self.services_running = (
                len(running_services) == len(expected) and len(starting_services) == 0
            )
        else:
            self.services_running = False

        # Check native service state
        self.docling_running = self.docling_manager.is_running()

        # Check for OAuth configuration
        self.has_oauth_config = bool(os.getenv("GOOGLE_OAUTH_CLIENT_ID")) or bool(
            os.getenv("MICROSOFT_GRAPH_OAUTH_CLIENT_ID")
        )

        # Set default button focus
        if self.services_running and self.docling_running:
            self.default_button_id = "open-app-btn"
        elif self.has_oauth_config:
            self.default_button_id = "advanced-setup-btn"
        else:
            self.default_button_id = "basic-setup-btn"

        # Refresh the welcome text AND buttons based on the updated async state
        # This ensures buttons match the actual service state (fixes issue where
        # text showed "All services running" but buttons weren't updated)
        await self._refresh_welcome_content()

    def _focus_appropriate_button(self) -> None:
        """Focus the appropriate button based on current state."""
        try:
            if self.services_running and self.docling_running:
                self.query_one("#open-app-btn").focus()
            elif self.has_oauth_config:
                self.query_one("#advanced-setup-btn").focus()
            else:
                self.query_one("#basic-setup-btn").focus()
        except Exception:
            pass  # Button might not exist

    async def on_screen_resume(self) -> None:
        """Called when returning from another screen (e.g., config screen)."""
        # Check if .env file exists (may have been created)
        self.has_env_file = self.env_manager.env_file.exists()

        # Reload environment variables
        load_dotenv(override=True)

        # Update OAuth config state
        self.has_oauth_config = bool(os.getenv("GOOGLE_OAUTH_CLIENT_ID")) or bool(
            os.getenv("MICROSOFT_GRAPH_OAUTH_CLIENT_ID")
        )

        # Re-detect container services using async method for accuracy
        if self.container_manager.is_available():
            services = await self.container_manager.get_service_status(force_refresh=True)
            expected = set(self.container_manager.expected_services)
            running_services = [
                s.name for s in services.values() if s.status == ServiceStatus.RUNNING
            ]
            starting_services = [
                s.name for s in services.values() if s.status == ServiceStatus.STARTING
            ]
            self.services_running = (
                len(running_services) == len(expected) and len(starting_services) == 0
            )
        else:
            self.services_running = False

        # Re-detect native service state
        self.docling_running = self.docling_manager.is_running()

        # Refresh the welcome content and buttons
        await self._refresh_welcome_content()

    def on_button_pressed(self, event: Button.Pressed) -> None:
        """Handle button presses."""
        if event.button.id == "basic-setup-btn":
            self.action_no_auth_setup()
        elif event.button.id == "advanced-setup-btn":
            self.action_full_setup()
        elif event.button.id == "status-btn":
            self.action_monitor()
        elif event.button.id == "diagnostics-btn":
            self.action_diagnostics()
        elif event.button.id == "start-all-services-btn":
            self.action_start_all_services()
        elif event.button.id == "stop-all-services-btn":
            self.action_stop_all_services()
        elif event.button.id == "open-app-btn":
            self.action_open_app()

    def action_default_action(self) -> None:
        """Handle Enter key - go to default action based on state."""
        if self.services_running and self.docling_running:
            self.action_open_app()
        elif self.has_oauth_config:
            self.action_full_setup()
        else:
            self.action_no_auth_setup()

    def action_no_auth_setup(self) -> None:
        """Switch to basic configuration screen."""
        from .config import ConfigScreen

        self.app.push_screen(ConfigScreen(mode="no_auth"))

    def action_full_setup(self) -> None:
        """Switch to advanced configuration screen."""
        from .config import ConfigScreen

        self.app.push_screen(ConfigScreen(mode="full"))

    def action_monitor(self) -> None:
        """Switch to monitoring screen."""
        from .monitor import MonitorScreen

        self.app.push_screen(MonitorScreen())

    def action_diagnostics(self) -> None:
        """Switch to diagnostics screen."""
        from .diagnostics import DiagnosticsScreen

        self.app.push_screen(DiagnosticsScreen())

    def action_refresh(self) -> None:
        """Refresh service state and update welcome screen."""
        self.run_worker(self._refresh_state())

    async def _refresh_state(self) -> None:
        """Async refresh of service state."""
        # Re-detect container services using async method for accuracy
        if self.container_manager.is_available():
            services = await self.container_manager.get_service_status(force_refresh=True)
            expected = set(self.container_manager.expected_services)
            running_services = [
                s.name for s in services.values() if s.status == ServiceStatus.RUNNING
            ]
            starting_services = [
                s.name for s in services.values() if s.status == ServiceStatus.STARTING
            ]
            self.services_running = (
                len(running_services) == len(expected) and len(starting_services) == 0
            )
        else:
            self.services_running = False

        # Re-detect native service state
        self.docling_running = self.docling_manager.is_running()

        # Update OAuth config state
        self.has_oauth_config = bool(os.getenv("GOOGLE_OAUTH_CLIENT_ID")) or bool(
            os.getenv("MICROSOFT_GRAPH_OAUTH_CLIENT_ID")
        )

        # Refresh the welcome content and buttons
        await self._refresh_welcome_content()
        self.notify("Refreshed", severity="information", timeout=2)

    def action_start_all_services(self) -> None:
        """Start all services (native first, then containers)."""
        self.run_worker(self._start_all_services())

    def action_stop_all_services(self) -> None:
        """Stop all services (containers first, then native)."""
        self.run_worker(self._stop_all_services())

    async def _on_services_operation_complete(self) -> None:
        """Handle completion of services start/stop operation."""
        # Use the same sync detection method that worked on startup
        self._detect_services_sync()

        # Update OAuth config state
        self.has_oauth_config = bool(os.getenv("GOOGLE_OAUTH_CLIENT_ID")) or bool(
            os.getenv("MICROSOFT_GRAPH_OAUTH_CLIENT_ID")
        )

        await self._refresh_welcome_content()

    def _update_default_button(self) -> None:
        """Update the default button target based on state."""
        if self.services_running and self.docling_running:
            self.default_button_id = "open-app-btn"
        elif self.has_oauth_config:
            self.default_button_id = "advanced-setup-btn"
        else:
            self.default_button_id = "basic-setup-btn"

    async def _refresh_welcome_content(self) -> None:
        """Refresh welcome text and buttons based on current state."""
        self._update_default_button()

        try:
            welcome_widget = self.query_one("#welcome-text", Static)
            welcome_widget.update(self._create_welcome_text())

            welcome_container = self.query_one("#welcome-container")

            # Remove existing button rows before mounting updated row
            for button_row in list(welcome_container.query(".button-row")):
                await button_row.remove()

            await welcome_container.mount(self._create_dynamic_buttons())
        except Exception:
            # Fallback - just refresh the whole screen
            self.refresh(layout=True)

        self.call_after_refresh(self._focus_appropriate_button)

    async def _start_all_services(self) -> None:
        """Start all services: containers first, then native services."""
        # Ensure password and secure defaults are set
        self.env_manager.load_existing_env()
        self.env_manager.setup_secure_defaults()
        self.env_manager.save_env_file()
        if not self.env_manager.config.langflow_superuser_password:
            self.notify("Langflow password is required. Cannot start services.", severity="error")
            return

        # Check for port conflicts before attempting to start anything
        conflicts: list[tuple[str, int, str]] = []

        # Check container ports only if services are not already running
        if self.container_manager.is_available() and not self.services_running:
            ports_available, port_conflicts = await self.container_manager.check_ports_available()
            if not ports_available:
                conflicts.extend(port_conflicts)

        # Check native service port only if it's not already running
        if not self.docling_manager.is_running():
            port_available, error_msg = self.docling_manager.check_port_available()
            if not port_available:
                conflicts.append(
                    (
                        "docling",
                        self.docling_manager._port,
                        error_msg or f"Port {self.docling_manager._port} is already in use",
                    )
                )

        # If there are any conflicts, show error and return
        if conflicts:
            self.notify(format_port_conflict_message(conflicts), severity="error", timeout=15)
            return

        # Step 1: Start container services first (to create the network)
        if self.container_manager.is_available() and not self.services_running:
            # Check for version mismatch before starting
            (
                has_mismatch,
                container_version,
                tui_version,
            ) = await self.container_manager.check_version_mismatch()
            if has_mismatch and container_version:
                # Show warning modal and wait for user decision
                should_continue = await self.app.push_screen_wait(
                    VersionMismatchWarningModal(container_version, tui_version)
                )
                if not should_continue:
                    self.notify("Start cancelled", severity="information")
                    return
                # Ensure OPENRAG_VERSION is set in .env BEFORE starting services
                # This ensures docker compose reads the correct version
                try:
                    from ..managers.env_manager import EnvManager

                    env_manager = EnvManager()
                    env_manager.ensure_openrag_version()
                    # Small delay to ensure .env file is written and flushed
                    import asyncio

                    await asyncio.sleep(0.5)
                except Exception:
                    pass  # Continue even if version setting fails

            command_generator = self.container_manager.start_services()
            modal = CommandOutputModal(
                "Starting Container Services",
                command_generator,
                on_complete=self._on_containers_started_start_native,
                show_launch_button=True,
            )
            self.app.push_screen(modal)
        elif self.services_running:
            # Containers already running, just start native services
            self.notify("Container services already running", severity="information")
            await self._start_native_services_after_containers()
        else:
            self.notify("No container runtime available", severity="warning")
            # Still try to start native services
            await self._start_native_services_after_containers()

    async def _on_containers_started_start_native(self) -> None:
        """Called after containers start successfully, now start native services."""
        # Update container state
        self._detect_services_sync()

        # Now start native services (docling-serve can now detect the compose network)
        await self._start_native_services_after_containers()

    async def _start_native_services_after_containers(self) -> None:
        """Start native services after containers have been started."""
        if not self.docling_manager.is_running():
            # Check for port conflicts before attempting to start
            port_available, error_msg = self.docling_manager.check_port_available()
            if not port_available:
                self.notify(
                    f"Cannot start native services: {error_msg}. "
                    f"Please stop the conflicting service first.",
                    severity="error",
                    timeout=10,
                )
                # Update state and return
                self.docling_running = False
                await self._refresh_welcome_content()
                return

            self.notify("Starting native services...", severity="information")
            success, message = await self.docling_manager.start()
            if success:
                self.notify(message, severity="information")
            else:
                self.notify(f"Failed to start native services: {message}", severity="error")
        else:
            self.notify("Native services already running", severity="information")

        # Update state
        self.docling_running = self.docling_manager.is_running()
        await self._refresh_welcome_content()

    async def _stop_all_services(self) -> None:
        """Stop all services: containers first, then native."""
        # Step 1: Stop container services
        if self.container_manager.is_available() and self.services_running:
            command_generator = self.container_manager.stop_services()
            modal = CommandOutputModal(
                "Stopping Container Services",
                command_generator,
                on_complete=self._on_stop_containers_complete,
            )
            self.app.push_screen(modal)
        else:
            # No containers to stop, go directly to stopping native services
            await self._stop_native_services_after_containers()

    async def _on_stop_containers_complete(self) -> None:
        """Called after containers are stopped, now stop native services."""
        # Update container state
        self._detect_services_sync()

        # Now stop native services
        await self._stop_native_services_after_containers()

    async def _stop_native_services_after_containers(self) -> None:
        """Stop native services after containers have been stopped."""
        if self.docling_manager.is_running():
            self.notify("Stopping native services...", severity="information")
            success, message = await self.docling_manager.stop()
            if success:
                self.notify(message, severity="information")
            else:
                self.notify(f"Failed to stop native services: {message}", severity="error")
        else:
            self.notify("Native services already stopped", severity="information")

        # Update state
        self.docling_running = self.docling_manager.is_running()
        await self._refresh_welcome_content()

    def action_open_app(self) -> None:
        """Open the OpenRAG app in the default browser."""
        import webbrowser

        try:
            # Get the frontend port from environment variable, defaulting to 3000
            frontend_port = os.getenv("FRONTEND_PORT", "3000")
            webbrowser.open(f"http://localhost:{frontend_port}")
            self.notify("Opening OpenRAG app in browser...", severity="information")
        except Exception as e:
            self.notify(f"Error opening app: {e}", severity="error")

    def action_quit(self) -> None:
        """Quit the application."""
        self.app.exit()