4runr-os 2.10.39 → 2.10.41

package/mk3-tui/src/monitoring/mod.rs

@@ -0,0 +1,428 @@
+// Phase 0: Portal Monitoring State Management
+// Structures for section-based, interactive monitoring
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+/// Main sections of the monitoring view
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum MonitoringSection {
+    Overview,
+    Health,
+    Dependencies,
+    Metrics,
+    Queue,
+    Logs,
+    System,
+}
+
+impl MonitoringSection {
+    pub fn all() -> Vec<Self> {
+        vec![
+            Self::Overview,
+            Self::Health,
+            Self::Dependencies,
+            Self::Metrics,
+            Self::Queue,
+            Self::Logs,
+            Self::System,
+        ]
+    }
+
+    pub fn display_name(&self) -> &'static str {
+        match self {
+            Self::Overview => "Overview",
+            Self::Health => "Health",
+            Self::Dependencies => "Dependencies",
+            Self::Metrics => "Metrics",
+            Self::Queue => "Queue",
+            Self::Logs => "Logs",
+            Self::System => "System",
+        }
+    }
+
+    /// Lowercase slug sent on `monitoring.refresh` (`section` field).
+    pub fn cli_slug(&self) -> &'static str {
+        match self {
+            Self::Overview => "overview",
+            Self::Health => "health",
+            Self::Dependencies => "dependencies",
+            Self::Metrics => "metrics",
+            Self::Queue => "queue",
+            Self::Logs => "logs",
+            Self::System => "system",
+        }
+    }
+
+    pub fn from_cli_slug(s: &str) -> Option<Self> {
+        let t = s.trim().to_lowercase();
+        match t.as_str() {
+            "overview" => Some(Self::Overview),
+            "health" => Some(Self::Health),
+            "dependencies" => Some(Self::Dependencies),
+            "metrics" => Some(Self::Metrics),
+            "queue" => Some(Self::Queue),
+            "logs" => Some(Self::Logs),
+            "system" => Some(Self::System),
+            _ => None,
+        }
+    }
+}
+
+/// Phase 3: Metrics section drill targets (`monitoring.drill` `target` field).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MetricsDrillPanel {
+    Http,
+    Runs,
+    Queue,
+    Sse,
+}
+
+impl MetricsDrillPanel {
+    pub fn next(self) -> Self {
+        match self {
+            Self::Http => Self::Runs,
+            Self::Runs => Self::Queue,
+            Self::Queue => Self::Sse,
+            Self::Sse => Self::Http,
+        }
+    }
+
+    pub fn cli_target(&self) -> &'static str {
+        match self {
+            Self::Http => "metrics_http",
+            Self::Runs => "metrics_runs",
+            Self::Queue => "metrics_queue",
+            Self::Sse => "metrics_sse",
+        }
+    }
+
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::Http => "HTTP",
+            Self::Runs => "Runs",
+            Self::Queue => "Queue",
+            Self::Sse => "SSE",
+        }
+    }
+
+    pub fn from_cli_target(s: &str) -> Option<Self> {
+        match s.trim() {
+            "metrics_http" => Some(Self::Http),
+            "metrics_runs" => Some(Self::Runs),
+            "metrics_queue" => Some(Self::Queue),
+            "metrics_sse" => Some(Self::Sse),
+            _ => None,
+        }
+    }
+}
+
+/// Status indicator for sections (determines color)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SectionStatus {
+    Healthy,   // Green
+    Degraded,  // Yellow
+    Unhealthy, // Red
+    Unknown,   // Gray
+    Loading,   // Blue/Cyan
+}
+
+impl SectionStatus {
+    pub fn symbol(&self) -> &'static str {
+        match self {
+            Self::Healthy => "●",
+            Self::Degraded => "⚠",
+            Self::Unhealthy => "✖",
+            Self::Unknown => "○",
+            Self::Loading => "◉",
+        }
+    }
+}
+
+/// State for each individual section.
+///
+/// **Phase 1 Portal Monitoring:** only `expanded` is authoritative for the UI. Status/summary strings
+/// here are not driven by `portal_monitoring` render (that path recomputes from the CLI snapshot each
+/// frame). Future phases may use `update_section` to populate these; until then do not assume headers
+/// reflect `SectionState::status` / `summary`.
+#[derive(Debug, Clone)]
+pub struct SectionState {
+    /// Whether section is expanded (shows detail) or collapsed (shows summary)
+    pub expanded: bool,
+    /// Current status (for color coding header)
+    pub status: SectionStatus,
+    /// One-line summary shown when collapsed
+    pub summary: String,
+    /// When this section was last refreshed
+    pub last_refresh: Option<Instant>,
+    /// Whether section is currently loading new data
+    pub loading: bool,
+    /// Error message if last refresh failed
+    pub error: Option<String>,
+    /// Arbitrary data payload (parsed from Gateway response)
+    pub data: Option<serde_json::Value>,
+}
+
+impl Default for SectionState {
+    fn default() -> Self {
+        Self {
+            expanded: false,
+            status: SectionStatus::Unknown,
+            summary: String::new(),
+            last_refresh: None,
+            loading: false,
+            error: None,
+            data: None,
+        }
+    }
+}
+
+/// Main monitoring state (Phase 0 foundation).
+///
+/// **Phase 1:** `selected_index` / `selected_section` and `sections[..].expanded` drive the TUI;
+/// per-section `SectionState::status` / `summary` are not used for drawing (see `build_body_lines` in
+/// `ui/portal_monitoring.rs` — status and one-line summaries come from `parse_snapshot` only).
+#[derive(Debug, Clone)]
+pub struct MonitoringState {
+    /// Currently selected section (for keyboard navigation)
+    pub selected_section: Option<MonitoringSection>,
+    /// Index in the section list (0 = Overview, 1 = Health, etc.)
+    pub selected_index: usize,
+    /// Per-section state
+    pub sections: HashMap<MonitoringSection, SectionState>,
+    /// Auto-refresh enabled/disabled
+    pub live_mode: bool,
+    /// Auto-refresh interval (default 5s)
+    pub refresh_interval: Duration,
+    /// When auto-refresh last triggered
+    pub last_auto_refresh: Option<Instant>,
+    /// Gateway URL we're monitoring
+    pub gateway_url: Option<String>,
+}
+
+impl Default for MonitoringState {
+    fn default() -> Self {
+        let mut sections = HashMap::new();
+        for section in MonitoringSection::all() {
+            sections.insert(section, SectionState::default());
+        }
+
+        Self {
+            selected_section: Some(MonitoringSection::Overview),
+            selected_index: 0,
+            sections,
+            live_mode: false, // Start with auto-refresh off
+            refresh_interval: Duration::from_secs(5),
+            last_auto_refresh: None,
+            gateway_url: None,
+        }
+    }
+}
+
+impl MonitoringState {
+    pub fn new(gateway_url: Option<String>) -> Self {
+        let mut state = Self::default();
+        state.gateway_url = gateway_url;
+        state
+    }
+
+    /// Get the currently selected section
+    pub fn current_section(&self) -> Option<MonitoringSection> {
+        self.selected_section
+    }
+
+    /// Move selection up (previous section)
+    pub fn select_previous(&mut self) {
+        if self.selected_index > 0 {
+            self.selected_index -= 1;
+            self.selected_section = Some(MonitoringSection::all()[self.selected_index]);
+        }
+    }
+
+    /// Move selection down (next section)
+    pub fn select_next(&mut self) {
+        let sections = MonitoringSection::all();
+        if self.selected_index < sections.len() - 1 {
+            self.selected_index += 1;
+            self.selected_section = Some(sections[self.selected_index]);
+        }
+    }
+
+    /// Toggle expand/collapse for currently selected section
+    pub fn toggle_current_section(&mut self) {
+        if let Some(section) = self.selected_section {
+            if let Some(state) = self.sections.get_mut(&section) {
+                state.expanded = !state.expanded;
+            }
+        }
+    }
+
+    /// Toggle expand/collapse for the section at `index` (Phase 1 Portal Monitoring).
+    pub fn toggle_section_at_index(&mut self, index: usize) {
+        let sections = MonitoringSection::all();
+        if let Some(&section) = sections.get(index) {
+            if let Some(state) = self.sections.get_mut(&section) {
+                state.expanded = !state.expanded;
+            }
+        }
+    }
+
+    /// Move selection with wrap (Phase 1).
+    pub fn select_previous_wrapped(&mut self) {
+        let n = MonitoringSection::all().len();
+        if n == 0 {
+            return;
+        }
+        self.selected_index = (self.selected_index + n - 1) % n;
+        self.selected_section = MonitoringSection::all().get(self.selected_index).copied();
+    }
+
+    pub fn select_next_wrapped(&mut self) {
+        let n = MonitoringSection::all().len();
+        if n == 0 {
+            return;
+        }
+        self.selected_index = (self.selected_index + 1) % n;
+        self.selected_section = MonitoringSection::all().get(self.selected_index).copied();
+    }
+
+    /// Expand a specific section
+    pub fn expand_section(&mut self, section: MonitoringSection) {
+        if let Some(state) = self.sections.get_mut(&section) {
+            state.expanded = true;
+        }
+    }
+
+    /// Collapse a specific section
+    pub fn collapse_section(&mut self, section: MonitoringSection) {
+        if let Some(state) = self.sections.get_mut(&section) {
+            state.expanded = false;
+        }
+    }
+
+    /// Collapse all sections
+    pub fn collapse_all(&mut self) {
+        for state in self.sections.values_mut() {
+            state.expanded = false;
+        }
+    }
+
+    /// Toggle auto-refresh (live mode)
+    pub fn toggle_live_mode(&mut self) {
+        self.live_mode = !self.live_mode;
+        if self.live_mode {
+            self.last_auto_refresh = Some(Instant::now());
+        }
+    }
+
+    /// Check if it's time for auto-refresh
+    pub fn should_auto_refresh(&self) -> bool {
+        if !self.live_mode {
+            return false;
+        }
+        match self.last_auto_refresh {
+            Some(last) => last.elapsed() >= self.refresh_interval,
+            None => true,
+        }
+    }
+
+    /// Mark that auto-refresh just happened
+    pub fn mark_auto_refresh(&mut self) {
+        self.last_auto_refresh = Some(Instant::now());
+    }
+
+    /// Set loading state for a section
+    pub fn set_loading(&mut self, section: MonitoringSection, loading: bool) {
+        if let Some(state) = self.sections.get_mut(&section) {
+            state.loading = loading;
+            if loading {
+                state.status = SectionStatus::Loading;
+                state.error = None;
+            }
+        }
+    }
+
+    /// Update section data after successful refresh
+    pub fn update_section(
+        &mut self,
+        section: MonitoringSection,
+        status: SectionStatus,
+        summary: String,
+        data: Option<serde_json::Value>,
+    ) {
+        if let Some(state) = self.sections.get_mut(&section) {
+            state.status = status;
+            state.summary = summary;
+            state.data = data;
+            state.last_refresh = Some(Instant::now());
+            state.loading = false;
+            state.error = None;
+        }
+    }
+
+    /// Set error state for a section
+    pub fn set_error(&mut self, section: MonitoringSection, error: String) {
+        if let Some(state) = self.sections.get_mut(&section) {
+            state.status = SectionStatus::Unhealthy;
+            state.error = Some(error);
+            state.loading = false;
+        }
+    }
+
+    /// Get section state (immutable)
+    pub fn get_section(&self, section: MonitoringSection) -> Option<&SectionState> {
+        self.sections.get(&section)
+    }
+
+    /// Get time since last refresh for a section (for display)
+    pub fn time_since_refresh(&self, section: MonitoringSection) -> Option<Duration> {
+        self.sections
+            .get(&section)
+            .and_then(|s| s.last_refresh)
+            .map(|t| t.elapsed())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_section_navigation() {
+        let mut state = MonitoringState::default();
+        assert_eq!(state.selected_index, 0);
+        assert_eq!(state.current_section(), Some(MonitoringSection::Overview));
+
+        state.select_next();
+        assert_eq!(state.selected_index, 1);
+        assert_eq!(state.current_section(), Some(MonitoringSection::Health));
+
+        state.select_previous();
+        assert_eq!(state.selected_index, 0);
+        assert_eq!(state.current_section(), Some(MonitoringSection::Overview));
+    }
+
+    #[test]
+    fn test_toggle_expansion() {
+        let mut state = MonitoringState::default();
+        state.selected_section = Some(MonitoringSection::Health);
+
+        let health = state.get_section(MonitoringSection::Health).unwrap();
+        assert!(!health.expanded);
+
+        state.toggle_current_section();
+        let health = state.get_section(MonitoringSection::Health).unwrap();
+        assert!(health.expanded);
+    }
+
+    #[test]
+    fn test_live_mode() {
+        let mut state = MonitoringState::default();
+        assert!(!state.live_mode);
+
+        state.toggle_live_mode();
+        assert!(state.live_mode);
+        assert!(state.last_auto_refresh.is_some());
+    }
+}

package/mk3-tui/src/screens/mod.rs

@@ -1,11 +1,10 @@
 /// Screen types and navigation system
-/// 
+///
 /// This module defines the screen/mode system for the TUI.
 /// Screens can be:
 /// - Base screens (Boot, Main) - always visible
 /// - Overlay screens (Agent Builder, Run Manager, Settings) - full-screen modals
 /// - Popup screens (Confirmations, Alerts) - small overlays
-
 use serde::{Deserialize, Serialize};
 
 /// Screen enum - represents all possible screens in the TUI
@@ -14,7 +13,7 @@ pub enum Screen {
     // Base screens
     Boot,
     Main,
-    
+
     // Overlay screens (full-screen modals)
     AgentBuilder,
     RunManager,
@@ -24,10 +23,15 @@ pub enum Screen {
     SetupPortal,
     /// Gateway traffic / server-style observability (scaffold; live stream TBD)
     PortalMonitoring,
-    
+
     // Popup screens (small overlays)
-    Confirmation { message: String, action: String },
-    Alert { message: String },
+    Confirmation {
+        message: String,
+        action: String,
+    },
+    Alert {
+        message: String,
+    },
 }
 
 impl Screen {
@@ -38,23 +42,24 @@ impl Screen {
             Screen::AgentBuilder | Screen::RunManager | Screen::Settings | Screen::AgentList
         )
     }
-    
+
     /// Returns true if this screen is a popup (small overlay)
     pub fn is_popup(&self) -> bool {
-        matches!(
-            self,
-            Screen::Confirmation { .. } | Screen::Alert { .. }
-        )
+        matches!(self, Screen::Confirmation { .. } | Screen::Alert { .. })
     }
-    
+
     /// Returns true if this screen is a base screen (full-screen standalone)
     pub fn is_base(&self) -> bool {
         matches!(
             self,
-            Screen::Boot | Screen::Main | Screen::ConnectionPortal | Screen::SetupPortal | Screen::PortalMonitoring
+            Screen::Boot
+                | Screen::Main
+                | Screen::ConnectionPortal
+                | Screen::SetupPortal
+                | Screen::PortalMonitoring
         )
     }
-    
+
     /// Returns the screen name for display
     #[allow(dead_code)]
     pub fn name(&self) -> &str {
@@ -79,11 +84,11 @@ impl Screen {
 pub struct NavigationState {
     /// Current base screen (Boot or Main)
     pub base_screen: Screen,
-    
+
     /// Overlay stack (full-screen modals)
     /// Last item is the currently visible overlay
     pub overlay_stack: Vec<Screen>,
-    
+
     /// Popup stack (small overlays on top of everything)
     /// Last item is the currently visible popup
     pub popup_stack: Vec<Screen>,
@@ -104,7 +109,7 @@ impl NavigationState {
     pub fn new() -> Self {
         Self::default()
     }
-    
+
     /// Get the currently visible screen (topmost in hierarchy)
     pub fn current_screen(&self) -> &Screen {
         // Priority: Popup > Overlay > Base
@@ -116,7 +121,7 @@ impl NavigationState {
             &self.base_screen
         }
     }
-    
+
     /// Navigate to a base screen (Boot or Main)
     pub fn navigate_to_base(&mut self, screen: Screen) {
         if screen.is_base() {
@@ -126,49 +131,49 @@ impl NavigationState {
             self.popup_stack.clear();
         }
     }
-    
+
     /// Push an overlay screen (Agent Builder, Run Manager, Settings)
     pub fn push_overlay(&mut self, screen: Screen) {
         if screen.is_overlay() {
             self.overlay_stack.push(screen);
         }
     }
-    
+
     /// Pop the current overlay and return to previous screen
     pub fn pop_overlay(&mut self) -> Option<Screen> {
         self.overlay_stack.pop()
     }
-    
+
     /// Push a popup screen (Confirmation, Alert, Help)
     pub fn push_popup(&mut self, screen: Screen) {
         if screen.is_popup() {
             self.popup_stack.push(screen);
         }
     }
-    
+
     /// Pop the current popup
     pub fn pop_popup(&mut self) -> Option<Screen> {
         self.popup_stack.pop()
     }
-    
+
     /// Close all overlays and popups (return to base screen)
     #[allow(dead_code)]
     pub fn close_all(&mut self) {
         self.overlay_stack.clear();
         self.popup_stack.clear();
     }
-    
+
     /// Check if we're currently on the base screen (no overlays/popups)
     #[allow(dead_code)]
     pub fn is_on_base(&self) -> bool {
         self.overlay_stack.is_empty() && self.popup_stack.is_empty()
     }
-    
+
     /// Check if we have any overlays open
     pub fn has_overlay(&self) -> bool {
         !self.overlay_stack.is_empty()
     }
-    
+
     /// Check if we have any popups open
     pub fn has_popup(&self) -> bool {
         !self.popup_stack.is_empty()
@@ -178,7 +183,7 @@ impl NavigationState {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_screen_classification() {
         assert!(Screen::Boot.is_base());
@@ -188,47 +193,56 @@ mod tests {
         assert!(Screen::Settings.is_overlay());
         assert!(Screen::Help.is_popup());
     }
-    
+
     #[test]
     fn test_navigation_state() {
         let mut nav = NavigationState::new();
-        
+
         // Start at Boot
         assert_eq!(nav.current_screen(), &Screen::Boot);
         assert!(nav.is_on_base());
-        
+
         // Navigate to Main
         nav.navigate_to_base(Screen::Main);
         assert_eq!(nav.current_screen(), &Screen::Main);
-        
+
         // Push overlay
         nav.push_overlay(Screen::AgentBuilder);
         assert_eq!(nav.current_screen(), &Screen::AgentBuilder);
         assert!(nav.has_overlay());
         assert!(!nav.is_on_base());
-        
+
         // Push popup
-        nav.push_popup(Screen::Alert { message: "Test".to_string() });
-        assert_eq!(nav.current_screen(), &Screen::Alert { message: "Test".to_string() });
+        nav.push_popup(Screen::Alert {
+            message: "Test".to_string(),
+        });
+        assert_eq!(
+            nav.current_screen(),
+            &Screen::Alert {
+                message: "Test".to_string()
+            }
+        );
         assert!(nav.has_popup());
-        
+
         // Pop popup
         nav.pop_popup();
         assert_eq!(nav.current_screen(), &Screen::AgentBuilder);
-        
+
         // Pop overlay
         nav.pop_overlay();
         assert_eq!(nav.current_screen(), &Screen::Main);
         assert!(nav.is_on_base());
     }
-    
+
     #[test]
     fn test_close_all() {
         let mut nav = NavigationState::new();
         nav.navigate_to_base(Screen::Main);
         nav.push_overlay(Screen::AgentBuilder);
-        nav.push_popup(Screen::Alert { message: "Test".to_string() });
-        
+        nav.push_popup(Screen::Alert {
+            message: "Test".to_string(),
+        });
+
         nav.close_all();
         assert!(nav.is_on_base());
         assert_eq!(nav.current_screen(), &Screen::Main);