4runr-os 2.10.39 → 2.10.40

package/mk3-tui/src/main.rs

@@ -11,6 +11,7 @@ use std::time::{Duration, Instant};
 mod app;
 mod debug_log;
 mod io;
+mod monitoring;
 mod screens;
 mod storage;
 mod ui;
@@ -407,6 +408,113 @@ fn main() -> Result<()> {
                                         }
                                         app.request_render("run_quick_ok");
                                     }
+                                    // Portal Monitoring Phase 2: monitoring.refresh (section slice)
+                                    else if Some(&resp.id) == app.state.pending_monitoring_refresh_id.as_ref() {
+                                        app.state.pending_monitoring_refresh_id = None;
+                                        app.state.portal_monitoring.section_refresh_loading = None;
+                                        if obj.get("monitoringRefresh").and_then(|v| v.as_bool()) == Some(true) {
+                                            let section_str =
+                                                obj.get("section").and_then(|v| v.as_str()).unwrap_or("");
+                                            use crate::monitoring::MonitoringSection;
+                                            if let Some(sec) = MonitoringSection::from_cli_slug(section_str)
+                                            {
+                                                let lines: Vec<String> = obj
+                                                    .get("lines")
+                                                    .and_then(|a| a.as_array())
+                                                    .map(|arr| {
+                                                        arr.iter()
+                                                            .filter_map(|v| {
+                                                                v.as_str().map(|s| s.to_string())
+                                                            })
+                                                            .collect()
+                                                    })
+                                                    .unwrap_or_default();
+                                                app.state
+                                                    .portal_monitoring
+                                                    .section_overrides
+                                                    .insert(sec, lines);
+                                            }
+                                        }
+                                        app.request_render("monitoring_refresh_ok");
+                                    }
+                                    // Portal Monitoring Phase 2: monitoring.logs
+                                    else if Some(&resp.id) == app.state.pending_monitoring_logs_id.as_ref() {
+                                        app.state.pending_monitoring_logs_id = None;
+                                        app.state.portal_monitoring.logs_fetch_loading = false;
+                                        if obj.get("monitoringLogs").and_then(|v| v.as_bool()) == Some(true) {
+                                            let lines: Vec<String> = obj
+                                                .get("logs")
+                                                .and_then(|a| a.as_array())
+                                                .map(|arr| {
+                                                    arr.iter()
+                                                        .filter_map(|entry| {
+                                                            let e = entry.as_object()?;
+                                                            let ts = e
+                                                                .get("timestamp")
+                                                                .and_then(|v| v.as_str())
+                                                                .unwrap_or("");
+                                                            let lvl = e
+                                                                .get("level")
+                                                                .and_then(|v| v.as_str())
+                                                                .unwrap_or("");
+                                                            let msg = e
+                                                                .get("message")
+                                                                .and_then(|v| v.as_str())
+                                                                .unwrap_or("");
+                                                            if ts.is_empty()
+                                                                && lvl.is_empty()
+                                                                && msg.is_empty()
+                                                            {
+                                                                return None;
+                                                            }
+                                                            Some(format!("{} [{}] {}", ts, lvl, msg))
+                                                        })
+                                                        .collect()
+                                                })
+                                                .unwrap_or_default();
+                                            use crate::monitoring::MonitoringSection;
+                                            app.state.portal_monitoring.section_overrides.insert(
+                                                MonitoringSection::Logs,
+                                                lines,
+                                            );
+                                        }
+                                        app.request_render("monitoring_logs_ok");
+                                    }
+                                    // Portal Monitoring Phase 3: monitoring.drill (metrics sub-panels / dependency detail)
+                                    else if Some(&resp.id) == app.state.pending_monitoring_drill_id.as_ref() {
+                                        app.state.pending_monitoring_drill_id = None;
+                                        app.state.portal_monitoring.metrics_drill_loading = false;
+                                        app.state.portal_monitoring.section_refresh_loading = None;
+                                        if obj.get("monitoringDrill").and_then(|v| v.as_bool()) == Some(true) {
+                                            let target = obj.get("target").and_then(|v| v.as_str()).unwrap_or("");
+                                            let lines: Vec<String> = obj
+                                                .get("lines")
+                                                .and_then(|a| a.as_array())
+                                                .map(|arr| {
+                                                    arr.iter()
+                                                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                                                        .collect()
+                                                })
+                                                .unwrap_or_default();
+                                            use crate::monitoring::{MetricsDrillPanel, MonitoringSection};
+                                            if target == "dependencies_detail" {
+                                                app.state.portal_monitoring.section_overrides.insert(
+                                                    MonitoringSection::Dependencies,
+                                                    lines,
+                                                );
+                                            } else if target == "system_diagnostics" {
+                                                app.state.portal_monitoring.section_overrides.insert(
+                                                    MonitoringSection::System,
+                                                    lines,
+                                                );
+                                            } else if let Some(panel) = MetricsDrillPanel::from_cli_target(target)
+                                            {
+                                                app.state.portal_monitoring.metrics_drill = Some(panel);
+                                                app.state.portal_monitoring.metrics_drill_lines = lines;
+                                            }
+                                        }
+                                        app.request_render("monitoring_drill_ok");
+                                    }
                                     // Portal Monitoring: gateway.observability (/metrics snapshot)
                                     else if Some(&resp.id) == app.state.pending_gateway_observability_id.as_ref() {
                                         app.state.pending_gateway_observability_id = None;
@@ -418,6 +526,8 @@ fn main() -> Result<()> {
                                                 .and_then(|v| v.as_str())
                                                 .unwrap_or("")
                                                 .to_string();
+                                            // Snapshot markers — keep substring order compatible with
+                                            // `portal_monitoring::SNAPSHOT_MARKER_*` (CLI healthLines + layout below).
                                             let mut lines: Vec<String> = vec![
                                                 "Portal snapshot (health + metrics on each refresh / auto poll)."
                                                     .to_string(),
@@ -447,8 +557,92 @@ fn main() -> Result<()> {
                                                     app.state.portal_monitoring.last_http_for_delta = Some(c);
                                                     app.state.portal_monitoring.last_instant_for_delta =
                                                         Some(std::time::Instant::now());
+                                                    app.state
+                                                        .portal_monitoring
+                                                        .http_total_sparkline
+                                                        .push_back(c);
+                                                    while app.state.portal_monitoring.http_total_sparkline.len() > 48 {
+                                                        app.state
+                                                            .portal_monitoring
+                                                            .http_total_sparkline
+                                                            .pop_front();
+                                                    }
+                                                }
+                                            }
+                                            if let Some(totals) = obj.get("totals").and_then(|v| v.as_object()) {
+                                                app.state.portal_monitoring.metric_history.push_back(
+                                                    crate::app::metric_history_entry_from_totals(
+                                                        if snapshot.is_empty() {
+                                                            "—".to_string()
+                                                        } else {
+                                                            snapshot.clone()
+                                                        },
+                                                        totals,
+                                                    ),
+                                                );
+                                                while app.state.portal_monitoring.metric_history.len() > 720 {
+                                                    app.state.portal_monitoring.metric_history.pop_front();
                                                 }
                                             }
+                                            // Phase 5 v1: dependency alerts are text-derived from
+                                            // observability health lines, not a structured readiness enum.
+                                            let dependency_status = {
+                                                let mut status = if obj
+                                                    .get("healthOk")
+                                                    .and_then(|v| v.as_bool())
+                                                    == Some(false)
+                                                {
+                                                    "unhealthy"
+                                                } else {
+                                                    "healthy"
+                                                };
+                                                if let Some(arr) = obj.get("healthLines").and_then(|a| a.as_array()) {
+                                                    for v in arr {
+                                                        if let Some(s) = v.as_str() {
+                                                            let l = s.to_lowercase();
+                                                            if l.contains("✗")
+                                                                || l.contains(": down")
+                                                                || l.contains("not ready")
+                                                            {
+                                                                status = "unhealthy";
+                                                                break;
+                                                            }
+                                                            if l.contains("⚠")
+                                                                || l.contains("degraded")
+                                                                || l.contains("warning")
+                                                            {
+                                                                status = "degraded";
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                status.to_string()
+                                            };
+                                            if let Some(prev) = app
+                                                .state
+                                                .portal_monitoring
+                                                .last_dependency_status
+                                                .clone()
+                                            {
+                                                if prev != dependency_status {
+                                                    app.state.portal_monitoring.dependency_alerts.push_back(
+                                                        crate::app::DependencyAlertEntry {
+                                                            timestamp: if snapshot.is_empty() {
+                                                                "—".to_string()
+                                                            } else {
+                                                                snapshot.clone()
+                                                            },
+                                                            previous: prev,
+                                                            current: dependency_status.clone(),
+                                                        },
+                                                    );
+                                                    while app.state.portal_monitoring.dependency_alerts.len() > 10 {
+                                                        app.state.portal_monitoring.dependency_alerts.pop_front();
+                                                    }
+                                                }
+                                            }
+                                            app.state.portal_monitoring.last_dependency_status =
+                                                Some(dependency_status);
                                             lines.push(String::new());
                                             if let Some(arr) = obj.get("healthLines").and_then(|a| a.as_array()) {
                                                 for v in arr {
@@ -495,6 +689,12 @@ fn main() -> Result<()> {
                                             }
                                             app.state.portal_monitoring.last_updated = Some(snapshot);
                                             app.state.portal_monitoring.content_lines = lines;
+                                            app.state.portal_monitoring.section_overrides.clear();
+                                            app.state.portal_monitoring.section_refresh_loading = None;
+                                            app.state.portal_monitoring.logs_fetch_loading = false;
+                                            app.state.portal_monitoring.metrics_drill = None;
+                                            app.state.portal_monitoring.metrics_drill_lines.clear();
+                                            app.state.portal_monitoring.metrics_drill_loading = false;
                                             app.state.portal_monitoring.error = None;
                                             app.state.portal_monitoring.scroll_offset = 0;
                                         } else {
@@ -593,8 +793,13 @@ fn main() -> Result<()> {
                                             app.add_log(format!("✓ [{}] Disconnected from Gateway", short_id));
                                             app.add_log(format!("[MODE] Switched to LOCAL mode"));
                                             app.state.pending_gateway_observability_id = None;
+                                            app.state.pending_monitoring_refresh_id = None;
+                                            app.state.pending_monitoring_logs_id = None;
+                                            app.state.pending_monitoring_drill_id = None;
                                             app.state.portal_observability_last_poll = None;
                                             app.state.portal_monitoring = crate::app::PortalMonitoringState::default();
+                                            app.state.advanced_monitoring =
+                                                crate::app::AdvancedMonitoringState::default();
                                             if let Some(ref ws) = ws_client {
                                                 let _ = ws.send_command("system.status", None);
                                             }
@@ -809,6 +1014,46 @@ fn main() -> Result<()> {
                                 app.state.portal_monitoring.error = Some(error_msg.clone());
                                 app.request_render("portal_observability_err");
                             }
+                            else if Some(&resp.id) == app.state.pending_monitoring_refresh_id.as_ref() {
+                                app.state.pending_monitoring_refresh_id = None;
+                                app.state.portal_monitoring.section_refresh_loading = None;
+                                app.state.portal_monitoring.error = Some(format!(
+                                    "monitoring.refresh failed: {}",
+                                    error_msg
+                                ));
+                                app.add_log(format!(
+                                    "✗ [{}] monitoring.refresh failed: {}",
+                                    short_id, error_msg
+                                ));
+                                app.request_render("monitoring_refresh_err");
+                            }
+                            else if Some(&resp.id) == app.state.pending_monitoring_logs_id.as_ref() {
+                                app.state.pending_monitoring_logs_id = None;
+                                app.state.portal_monitoring.logs_fetch_loading = false;
+                                app.state.portal_monitoring.error = Some(format!(
+                                    "monitoring.logs failed: {}",
+                                    error_msg
+                                ));
+                                app.add_log(format!(
+                                    "✗ [{}] monitoring.logs failed: {}",
+                                    short_id, error_msg
+                                ));
+                                app.request_render("monitoring_logs_err");
+                            }
+                            else if Some(&resp.id) == app.state.pending_monitoring_drill_id.as_ref() {
+                                app.state.pending_monitoring_drill_id = None;
+                                app.state.portal_monitoring.metrics_drill_loading = false;
+                                app.state.portal_monitoring.section_refresh_loading = None;
+                                app.state.portal_monitoring.error = Some(format!(
+                                    "monitoring.drill failed: {}",
+                                    error_msg
+                                ));
+                                app.add_log(format!(
+                                    "✗ [{}] monitoring.drill failed: {}",
+                                    short_id, error_msg
+                                ));
+                                app.request_render("monitoring_drill_err");
+                            }
                             // Generic error handling
                             else {
                                 // Try to extract command name from response for better error messages
@@ -856,6 +1101,9 @@ fn main() -> Result<()> {
                 if app.state.navigation.current_screen() == &Screen::PortalMonitoring
                     && app.state.operation_mode == OperationMode::Connected
                     && app.state.pending_gateway_observability_id.is_none()
+                    && app.state.pending_monitoring_refresh_id.is_none()
+                    && app.state.pending_monitoring_logs_id.is_none()
+                    && app.state.pending_monitoring_drill_id.is_none()
                 {
                     let interval = Duration::from_secs(5);
                     let due = app