Function run_app

cake-cli/src/chat.rs:896–1118

(
    terminal: &mut Terminal<ratatui::backend::CrosstermBackend<io::Stdout>>,
    server: &str,
)

}

async fn run_app(
    terminal: &mut Terminal<ratatui::backend::CrosstermBackend<io::Stdout>>,
    server: &str,
) -> Result<()> {
    let mut app = App::new(server);
    let client = Client::new();
    let mut response_rx: Option<tokio::sync::mpsc::UnboundedReceiver<Option<String>>> = None;
    let mut gen_start: Option<Instant> = None;
    let mut token_count: usize = 0;
    let mut last_topology_fetch = Instant::now() - std::time::Duration::from_secs(60);

    loop {
        // Fetch topology periodically (every 10s) or on first switch to cluster tab
        if app.tab == Tab::Cluster
            && last_topology_fetch.elapsed() > std::time::Duration::from_secs(10)
        {
            if let Ok(topo) = fetch_topology(&client, server).await {
                app.topology = Some(topo);
            }
            last_topology_fetch = Instant::now();
        }

        terminal.draw(|f| draw(f, &mut app))?;

        if app.should_quit {
            break;
        }

        let timeout = std::time::Duration::from_millis(16);

        tokio::select! {
            _ = tokio::time::sleep(timeout) => {
                while event::poll(std::time::Duration::ZERO)? {
                    if let Event::Key(key) = event::read()? {
                        if key.kind != KeyEventKind::Press {
                            continue;
                        }
                        match key.code {
                            KeyCode::Esc => {
                                app.should_quit = true;
                            }
                            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                                app.should_quit = true;
                            }
                            // Tab switching
                            KeyCode::Char('1') if !app.streaming => {
                                app.tab = Tab::Chat;
                            }
                            KeyCode::Char('2') if !app.streaming => {
                                app.tab = Tab::Cluster;
                                // Force immediate fetch
                                if app.topology.is_none() {
                                    last_topology_fetch = Instant::now() - std::time::Duration::from_secs(60);
                                }
                            }
                            KeyCode::Tab if !app.streaming => {
                                app.tab = match app.tab {
                                    Tab::Chat => Tab::Cluster,