4runr-os 2.10.77 → 2.10.78

package/mk3-tui/src/ui/shield_dashboard.rs

@@ -36,42 +36,62 @@ pub struct ShieldBlockRow {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ShieldTab {
+    Activity,
     Overview,
     Enforcement,
-    Help,
 }
 
 impl ShieldTab {
     pub fn label(self) -> &'static str {
         match self {
+            ShieldTab::Activity => "Activity",
             ShieldTab::Overview => "Overview",
             ShieldTab::Enforcement => "Enforcement",
-            ShieldTab::Help => "Help",
         }
     }
 
     pub fn next(self) -> Self {
         match self {
+            ShieldTab::Activity => ShieldTab::Overview,
             ShieldTab::Overview => ShieldTab::Enforcement,
-            ShieldTab::Enforcement => ShieldTab::Help,
-            ShieldTab::Help => ShieldTab::Overview,
+            ShieldTab::Enforcement => ShieldTab::Activity,
         }
     }
 
     pub fn prev(self) -> Self {
         match self {
-            ShieldTab::Overview => ShieldTab::Help,
+            ShieldTab::Activity => ShieldTab::Enforcement,
+            ShieldTab::Overview => ShieldTab::Activity,
             ShieldTab::Enforcement => ShieldTab::Overview,
-            ShieldTab::Help => ShieldTab::Enforcement,
         }
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct ShieldActivityRow {
+    pub at: String,
+    pub kind: String,
+    pub run_id: Option<String>,
+    pub run_name: Option<String>,
+    pub detail: String,
+    pub source: String,
+}
+
 #[derive(Debug, Clone)]
 pub struct ShieldDashboardState {
     pub tab: ShieldTab,
     pub selected_block_index: usize,
+    pub selected_activity_index: usize,
     pub loaded_once: bool,
+    pub snapshot_at: String,
+    pub blocks_delta: i64,
+    pub masks_delta: i64,
+    pub decisions_delta: i64,
+    pub breakdown_lines: Vec<String>,
+    pub activity_events: Vec<ShieldActivityRow>,
+    prev_blocks: u64,
+    prev_masks: u64,
+    prev_decisions: u64,
     pub enabled: bool,
     pub mode: String,
     pub health_status: String,
@@ -97,9 +117,19 @@ pub struct ShieldDashboardState {
 impl Default for ShieldDashboardState {
     fn default() -> Self {
         Self {
-            tab: ShieldTab::Overview,
+            tab: ShieldTab::Activity,
             selected_block_index: 0,
+            selected_activity_index: 0,
             loaded_once: false,
+            snapshot_at: String::new(),
+            blocks_delta: 0,
+            masks_delta: 0,
+            decisions_delta: 0,
+            breakdown_lines: Vec::new(),
+            activity_events: Vec::new(),
+            prev_blocks: 0,
+            prev_masks: 0,
+            prev_decisions: 0,
             enabled: false,
             mode: "off".to_string(),
             health_status: String::new(),
@@ -133,11 +163,33 @@ impl ShieldDashboardState {
         metrics: &ShieldMetricsSnap,
         warnings: Vec<String>,
         recent: Vec<ShieldBlockRow>,
+        activity: Vec<ShieldActivityRow>,
+        breakdown_lines: Vec<String>,
+        snapshot_at: String,
     ) {
+        if self.loaded_once {
+            self.blocks_delta = metrics.blocks as i64 - self.prev_blocks as i64;
+            self.masks_delta = metrics.masks as i64 - self.prev_masks as i64;
+            self.decisions_delta = metrics.decisions as i64 - self.prev_decisions as i64;
+        } else {
+            self.blocks_delta = 0;
+            self.masks_delta = 0;
+            self.decisions_delta = 0;
+        }
+        self.prev_blocks = metrics.blocks;
+        self.prev_masks = metrics.masks;
+        self.prev_decisions = metrics.decisions;
+
         self.loading = false;
         self.loading_started = None;
         self.error = None;
         self.loaded_once = true;
+        self.snapshot_at = snapshot_at;
+        self.activity_events = activity;
+        self.breakdown_lines = breakdown_lines;
+        if self.selected_activity_index >= self.activity_events.len() {
+            self.selected_activity_index = 0;
+        }
         self.enabled = health.enabled;
         self.mode = health.mode.clone();
         self.health_status = health.status.clone();
@@ -368,6 +420,91 @@ pub fn parse_shield_load(
     (health, config, metrics, warnings, recent)
 }
 
+pub fn parse_shield_activity(val: &Value) -> Vec<ShieldActivityRow> {
+    let Some(arr) = val.as_array() else {
+        return Vec::new();
+    };
+    arr.iter()
+        .filter_map(|item| {
+            let o = item.as_object()?;
+            Some(ShieldActivityRow {
+                at: o
+                    .get("at")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.chars().take(19).collect())
+                    .unwrap_or_else(|| "—".to_string()),
+                kind: o
+                    .get("kind")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("log")
+                    .to_string(),
+                run_id: o
+                    .get("runId")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string()),
+                run_name: o
+                    .get("runName")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string()),
+                detail: o
+                    .get("detail")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("")
+                    .to_string(),
+                source: o
+                    .get("source")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("?")
+                    .to_string(),
+            })
+        })
+        .collect()
+}
+
+pub fn parse_shield_breakdown(val: &Value) -> Vec<String> {
+    val.get("breakdownLines")
+        .and_then(|v| v.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|x| x.as_str().map(|s| s.to_string()))
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn format_delta(delta: i64) -> String {
+    if delta > 0 {
+        format!(" +{}", delta)
+    } else if delta < 0 {
+        format!(" {}", delta)
+    } else {
+        String::new()
+    }
+}
+
+fn refresh_ago(sd: &ShieldDashboardState) -> String {
+    sd.last_refresh
+        .map(|lr| {
+            let s = lr.elapsed().as_secs();
+            if s < 60 {
+                format!("{}s ago", s)
+            } else {
+                format!("{}m ago", s / 60)
+            }
+        })
+        .unwrap_or_else(|| "—".to_string())
+}
+
+fn kind_color(kind: &str) -> Color {
+    match kind {
+        "block" => SHIELD_ORANGE,
+        "mask" => CYBER_CYAN,
+        "flag" => AMBER_WARN,
+        "rewrite" => AMBER_WARN,
+        _ => TEXT_DIM,
+    }
+}
+
 pub fn render(f: &mut Frame, state: &AppState) {
     let area = f.size();
     let sd = &state.shield_dashboard;
@@ -380,16 +517,34 @@ pub fn render(f: &mut Frame, state: &AppState) {
         ""
     };
     let live = if sd.auto_refresh_enabled { " · LIVE" } else { "" };
+    let delta_blk = if sd.loaded_once {
+        format_delta(sd.blocks_delta)
+    } else {
+        String::new()
+    };
+    let delta_mask = if sd.loaded_once {
+        format_delta(sd.masks_delta)
+    } else {
+        String::new()
+    };
+    let ago = if sd.loaded_once {
+        format!(" · {}", refresh_ago(sd))
+    } else {
+        String::new()
+    };
     let header_title = format!(
-        " 🛡️  Shield — {} · {} block(s) · {} mask(s){}{} ",
+        " 🛡️  Shield — {} · {} blk{}{} mask{}{}{}{} ",
         if sd.loaded_once {
             sd.mode.to_uppercase()
         } else {
             "…".to_string()
         },
         sd.blocks_total,
+        delta_blk,
         sd.masks_total,
+        delta_mask,
         live,
+        ago,
         refresh_hint
     );
 
@@ -433,6 +588,7 @@ pub fn render(f: &mut Frame, state: &AppState) {
         );
     } else {
         match sd.tab {
+            ShieldTab::Activity => render_activity_panel(f, chunks[2], sd),
             ShieldTab::Overview => {
                 let mid = Layout::default()
                     .direction(Direction::Horizontal)
@@ -442,7 +598,6 @@ pub fn render(f: &mut Frame, state: &AppState) {
                 render_metrics_panel(f, mid[1], sd);
             }
             ShieldTab::Enforcement => render_enforcement_panel(f, chunks[2], sd),
-            ShieldTab::Help => render_help_panel(f, chunks[2], sd),
         }
     }
 
@@ -453,9 +608,14 @@ pub fn render(f: &mut Frame, state: &AppState) {
     } else {
         String::new()
     };
+    let nav_hint = match sd.tab {
+        ShieldTab::Activity => "↑↓ Select event · Enter Open run",
+        ShieldTab::Enforcement => "↑↓ Select block · Enter Open run",
+        ShieldTab::Overview => "Overview — counters update on refresh",
+    };
     let footer_msg = format!(
-        "{}Tab/←→ Switch view · ↑↓ Select block · Enter Open run · R Refresh · O Runs · P Monitoring · A Live · ESC Close",
-        status_line
+        "{}Tab/←→ Switch · {} · R Refresh · A Live · ESC Close",
+        status_line, nav_hint
     );
     let footer_color = if sd.error.is_some() {
         Color::Rgb(255, 69, 69)
@@ -477,7 +637,7 @@ pub fn render(f: &mut Frame, state: &AppState) {
 }
 
 fn render_tab_bar(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
-    let tabs = [ShieldTab::Overview, ShieldTab::Enforcement, ShieldTab::Help];
+    let tabs = [ShieldTab::Activity, ShieldTab::Overview, ShieldTab::Enforcement];
     let spans: Vec<Span> = tabs
         .iter()
         .flat_map(|tab| {
@@ -507,35 +667,197 @@ fn render_tab_bar(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
     f.render_widget(block, area);
 }
 
-fn render_help_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
-    let block = Block::default()
-        .title(" How Shield works in production ")
+fn render_activity_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
+    use ratatui::layout::{Constraint, Direction, Layout};
+
+    let outer = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Length(3), Constraint::Min(6)])
+        .split(area);
+
+    let counter_block = Block::default()
+        .title(format!(
+            " Live counters (refreshed {}) ",
+            refresh_ago(sd)
+        ))
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(NEON_GREEN));
+    let counter_inner = counter_block.inner(outer[0]);
+    f.render_widget(counter_block, outer[0]);
+    f.render_widget(
+        Paragraph::new(Line::from(vec![
+            Span::styled("Decisions ", Style::default().fg(TEXT_DIM)),
+            Span::styled(
+                sd.decisions_total.to_string(),
+                Style::default().fg(TEXT_PRIMARY).bold(),
+            ),
+            Span::styled(
+                format_delta(sd.decisions_delta),
+                Style::default().fg(if sd.decisions_delta > 0 {
+                    NEON_GREEN
+                } else {
+                    TEXT_MUTED
+                }),
+            ),
+            Span::raw("   "),
+            Span::styled("Blocks ", Style::default().fg(TEXT_DIM)),
+            Span::styled(
+                sd.blocks_total.to_string(),
+                Style::default().fg(SHIELD_ORANGE).bold(),
+            ),
+            Span::styled(
+                format_delta(sd.blocks_delta),
+                Style::default().fg(if sd.blocks_delta > 0 {
+                    NEON_GREEN
+                } else {
+                    TEXT_MUTED
+                }),
+            ),
+            Span::raw("   "),
+            Span::styled("Masks ", Style::default().fg(TEXT_DIM)),
+            Span::styled(
+                sd.masks_total.to_string(),
+                Style::default().fg(CYBER_CYAN).bold(),
+            ),
+            Span::styled(
+                format_delta(sd.masks_delta),
+                Style::default().fg(if sd.masks_delta > 0 {
+                    NEON_GREEN
+                } else {
+                    TEXT_MUTED
+                }),
+            ),
+            Span::raw("   "),
+            Span::styled("Rewrites ", Style::default().fg(TEXT_DIM)),
+            Span::styled(
+                sd.rewrites_total.to_string(),
+                Style::default().fg(AMBER_WARN).bold(),
+            ),
+        ])),
+        counter_inner,
+    );
+
+    let body = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Percentage(62), Constraint::Percentage(38)])
+        .split(outer[1]);
+
+    let feed_title = format!(
+        " Shield events ({}) — ↑↓ select · Enter open run ",
+        sd.activity_events.len()
+    );
+    let feed_block = Block::default()
+        .title(feed_title)
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(SHIELD_ORANGE))
+        .style(Style::default().bg(BG_PANEL));
+    let feed_inner = feed_block.inner(body[0]);
+    f.render_widget(feed_block, body[0]);
+
+    if sd.activity_events.is_empty() {
+        let empty = vec![
+            Line::from(""),
+            Line::from("No Shield events in recent Gateway history yet.")
+                .style(Style::default().fg(TEXT_DIM)),
+            Line::from(""),
+            Line::from("Counters above update from Prometheus on every refresh.")
+                .style(Style::default().fg(TEXT_MUTED)),
+            Line::from("Run an agent with injection/PII to see blocks and masks here.")
+                .style(Style::default().fg(TEXT_MUTED)),
+        ];
+        f.render_widget(Paragraph::new(empty).alignment(Alignment::Center), feed_inner);
+    } else {
+        let items: Vec<ListItem> = sd
+            .activity_events
+            .iter()
+            .enumerate()
+            .map(|(idx, e)| {
+                let selected = idx == sd.selected_activity_index;
+                let prefix = if selected { "▶ " } else { "  " };
+                let kind_upper = e.kind.to_uppercase();
+                let run_hint = e
+                    .run_name
+                    .clone()
+                    .or_else(|| {
+                        e.run_id.as_ref().map(|id| {
+                            if id.len() > 8 {
+                                id[id.len() - 8..].to_string()
+                            } else {
+                                id.clone()
+                            }
+                        })
+                    })
+                    .unwrap_or_else(|| "—".to_string());
+                ListItem::new(Line::from(vec![
+                    Span::styled(prefix, Style::default().fg(SHIELD_ORANGE).bold()),
+                    Span::styled(
+                        format!("{} ", e.at),
+                        Style::default().fg(TEXT_MUTED),
+                    ),
+                    Span::styled(
+                        format!("[{}] ", kind_upper),
+                        Style::default().fg(kind_color(&e.kind)).bold(),
+                    ),
+                    Span::styled(
+                        format!("{} ", run_hint),
+                        Style::default().fg(if selected { CYBER_CYAN } else { TEXT_PRIMARY }),
+                    ),
+                    Span::styled(
+                        e.detail.chars().take(52).collect::<String>(),
+                        Style::default().fg(TEXT_DIM),
+                    ),
+                    Span::styled(
+                        format!(" ({})", e.source),
+                        Style::default().fg(TEXT_MUTED),
+                    ),
+                ]))
+            })
+            .collect();
+        f.render_widget(List::new(items), feed_inner);
+    }
+
+    let breakdown_block = Block::default()
+        .title(" Prometheus breakdown ")
         .borders(Borders::ALL)
         .border_style(Style::default().fg(BRAND_PURPLE))
         .style(Style::default().bg(BG_PANEL));
-    let inner = block.inner(area);
-    f.render_widget(block, area);
+    let breakdown_inner = breakdown_block.inner(body[1]);
+    f.render_widget(breakdown_block, body[1]);
 
-    let mut lines: Vec<Line> = ABOUT_SHIELD
-        .iter()
-        .map(|l| Line::from(*l).style(Style::default().fg(TEXT_PRIMARY)))
-        .collect();
-    lines.push(Line::from(""));
-    lines.push(
-        Line::from("Navigation from this screen:")
-            .style(Style::default().fg(NEON_GREEN).bold()),
-    );
-    lines.push(Line::from("  O — open Run Manager (all runs, SHIELD badge on blocks)"));
-    lines.push(Line::from("  P — open Portal Monitoring (Prometheus Shield counters)"));
-    lines.push(Line::from("  Enforcement tab → Enter on a row opens that blocked run"));
+    let mut breakdown_lines: Vec<Line> = Vec::new();
+    if !sd.snapshot_at.is_empty() {
+        breakdown_lines.push(Line::from(vec![
+            Span::styled("Snapshot: ", Style::default().fg(TEXT_DIM)),
+            Span::styled(
+                sd.snapshot_at.chars().take(19).collect::<String>(),
+                Style::default().fg(TEXT_MUTED),
+            ),
+        ]));
+        breakdown_lines.push(Line::from(""));
+    }
+    for line in &sd.breakdown_lines {
+        let style = if line.ends_with(':') || !line.starts_with(' ') {
+            Style::default().fg(NEON_GREEN).bold()
+        } else {
+            Style::default().fg(TEXT_PRIMARY)
+        };
+        breakdown_lines.push(Line::from(line.as_str()).style(style));
+    }
     if !sd.warnings.is_empty() {
-        lines.push(Line::from(""));
-        lines.push(Line::from("Active warnings:").style(Style::default().fg(AMBER_WARN).bold()));
+        breakdown_lines.push(Line::from(""));
+        breakdown_lines.push(
+            Line::from("Warnings:").style(Style::default().fg(AMBER_WARN).bold()),
+        );
         for w in &sd.warnings {
-            lines.push(Line::from(format!("  ⚠ {}", w)).style(Style::default().fg(AMBER_WARN)));
+            breakdown_lines.push(
+                Line::from(format!("  ⚠ {}", w)).style(Style::default().fg(AMBER_WARN)),
+            );
         }
     }
-    f.render_widget(Paragraph::new(lines).wrap(Wrap { trim: false }), inner);
+    f.render_widget(
+        Paragraph::new(breakdown_lines).wrap(Wrap { trim: false }),
+        breakdown_inner,
+    );
 }
 
 fn render_status_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
@@ -597,8 +919,18 @@ fn render_status_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
     }
 
     lines.push(Line::from(""));
-    for line in ABOUT_SHIELD.iter().take(4) {
-        lines.push(Line::from(*line).style(Style::default().fg(TEXT_MUTED)));
+    lines.push(Line::from(vec![
+        Span::styled("Last refresh: ", Style::default().fg(TEXT_DIM)),
+        Span::styled(refresh_ago(sd), Style::default().fg(TEXT_MUTED)),
+    ]));
+    if let Some(first) = sd.activity_events.first() {
+        lines.push(Line::from(vec![
+            Span::styled("Latest event: ", Style::default().fg(TEXT_DIM)),
+            Span::styled(
+                format!("[{}] {}", first.kind.to_uppercase(), first.detail.chars().take(40).collect::<String>()),
+                Style::default().fg(kind_color(&first.kind)),
+            ),
+        ]));
     }
 
     f.render_widget(Paragraph::new(lines).wrap(Wrap { trim: false }), inner);
@@ -627,18 +959,16 @@ fn render_metrics_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
 
     let lines = vec![
         Line::from(""),
-        metric_line("Decisions total", sd.decisions_total, TEXT_PRIMARY),
-        metric_line("Blocks total", sd.blocks_total, SHIELD_ORANGE),
-        metric_line("Masks total", sd.masks_total, CYBER_CYAN),
+        metric_line_delta("Decisions", sd.decisions_total, sd.decisions_delta, TEXT_PRIMARY),
+        metric_line_delta("Blocks", sd.blocks_total, sd.blocks_delta, SHIELD_ORANGE),
+        metric_line_delta("Masks", sd.masks_total, sd.masks_delta, CYBER_CYAN),
         metric_line("Rewrites total", sd.rewrites_total, AMBER_WARN),
         Line::from(""),
+        Line::from(format!("Refreshed {}", refresh_ago(sd))).style(Style::default().fg(TEXT_MUTED)),
         Line::from("Source: Gateway Prometheus /metrics").style(Style::default().fg(TEXT_MUTED)),
-        Line::from("Updates on refresh — counts all production runs.").style(Style::default().fg(TEXT_MUTED)),
+        Line::from("+N = change since last refresh on this screen.").style(Style::default().fg(TEXT_MUTED)),
         Line::from(""),
-        Line::from(ABOUT_SHIELD[4]).style(Style::default().fg(TEXT_DIM)),
-        Line::from(ABOUT_SHIELD[5]).style(Style::default().fg(TEXT_DIM)),
-        Line::from(ABOUT_SHIELD[6]).style(Style::default().fg(TEXT_DIM)),
-        Line::from(ABOUT_SHIELD[7]).style(Style::default().fg(TEXT_DIM)),
+        Line::from("Activity tab shows live event feed + breakdown.").style(Style::default().fg(NEON_GREEN)),
     ];
 
     f.render_widget(Paragraph::new(lines), inner);
@@ -654,6 +984,20 @@ fn metric_line(label: &str, value: u64, color: Color) -> Line<'static> {
     ])
 }
 
+fn metric_line_delta(label: &str, value: u64, delta: i64, color: Color) -> Line<'static> {
+    Line::from(vec![
+        Span::styled(format!("  {:<18}", label), Style::default().fg(TEXT_DIM)),
+        Span::styled(
+            value.to_string(),
+            Style::default().fg(color).bold(),
+        ),
+        Span::styled(
+            format_delta(delta),
+            Style::default().fg(if delta > 0 { NEON_GREEN } else { TEXT_MUTED }),
+        ),
+    ])
+}
+
 fn render_enforcement_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
     let block = Block::default()
         .title(format!(
@@ -672,7 +1016,7 @@ fn render_enforcement_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState
             Line::from("No blocked runs in Gateway history yet.").style(Style::default().fg(TEXT_DIM)),
             Line::from(""),
             Line::from("Shield still evaluates every agent/API run on input.").style(Style::default().fg(TEXT_MUTED)),
-            Line::from("Press O to open Run Manager · P for live Prometheus metrics.").style(Style::default().fg(NEON_GREEN)),
+            Line::from("Activity tab shows live counters and event feed on refresh.").style(Style::default().fg(NEON_GREEN)),
         ];
         f.render_widget(Paragraph::new(empty).alignment(Alignment::Center), inner);
         return;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "4runr-os",
-  "version": "2.10.77",
+  "version": "2.10.78",
   "type": "module",
-  "description": "4Runr AI Agent OS - Secure terminal interface for AI agents. v2.10.77: Fix Shield dashboard load — shield.load response no longer swallowed by legacy handler.",
+  "description": "4Runr AI Agent OS - Secure terminal interface for AI agents. v2.10.78: Shield Activity tab — live event feed, metric deltas, and Prometheus breakdown on-screen.",
   "main": "dist/index.js",
   "bin": {
     "4runr": "dist/index.js",