4runr-os 2.1.21 → 2.1.22

package/mk3-tui/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "mk3-tui"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ratatui = "0.27"
+crossterm = "0.28"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio-tungstenite = "0.24"
+tungstenite = "0.24"
+anyhow = "1"
+thiserror = "2"
+

package/mk3-tui/bin/mk3-tui.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Try to find the binary in different locations
+const possiblePaths = [
+  // From npm package (installed)
+  join(__dirname, '..', 'target', 'release', 'mk3-tui'),
+  join(__dirname, '..', 'target', 'release', 'mk3-tui.exe'),
+  // From global npm install (in PATH)
+  process.platform === 'win32' ? 'mk3-tui.exe' : 'mk3-tui',
+  // Development build (local)
+  join(__dirname, '..', '..', '..', 'apps', 'mk3-tui', 'target', 'release', 'mk3-tui'),
+  join(__dirname, '..', '..', '..', 'apps', 'mk3-tui', 'target', 'release', 'mk3-tui.exe'),
+];
+
+let binaryPath = null;
+for (const testPath of possiblePaths) {
+  // Check if it's a PATH command (string without slashes)
+  if (!testPath.includes('/') && !testPath.includes('\\')) {
+    // Try to find in PATH
+    try {
+      const { execSync } = await import('child_process');
+      const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+      execSync(`${whichCmd} ${testPath}`, { stdio: 'ignore' });
+      binaryPath = testPath;
+      break;
+    } catch {
+      continue;
+    }
+  } else if (existsSync(testPath)) {
+    binaryPath = testPath;
+    break;
+  }
+}
+
+if (!binaryPath) {
+  console.error('Error: mk3-tui binary not found.');
+  console.error('Please run: cd apps/mk3-tui && cargo build --release');
+  process.exit(1);
+}
+
+// Spawn the Rust binary with all arguments
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  cwd: process.cwd(),
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start mk3-tui:', err);
+  process.exit(1);
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});
+

package/mk3-tui/src/app/render_scheduler.rs

@@ -0,0 +1,103 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum RunMode {
+    Local,
+    Browser,
+}
+
+impl RunMode {
+    pub fn detect() -> Self {
+        if let Ok(mode) = std::env::var("RUN_MODE") {
+            match mode.to_lowercase().as_str() {
+                "browser" | "web" => return RunMode::Browser,
+                "local" => return RunMode::Local,
+                _ => {}
+            }
+        }
+        
+        // Auto-detect
+        if std::env::var("AWS_EXECUTION_ENV").is_ok()
+            || std::env::var("CLOUDSHELL").is_ok()
+            || std::env::var("TUI_WEB").map(|v| v == "1").unwrap_or(false)
+        {
+            RunMode::Browser
+        } else {
+            RunMode::Local
+        }
+    }
+}
+
+pub struct RenderScheduler {
+    run_mode: RunMode,
+    last_render: Instant,
+    render_scheduled: bool,
+    render_scheduled_count: u64,
+    min_render_interval: Duration,
+}
+
+impl RenderScheduler {
+    pub fn new() -> Self {
+        let run_mode = RunMode::detect();
+        let min_render_interval = match run_mode {
+            RunMode::Browser => Duration::from_millis(100), // Max 10 FPS
+            RunMode::Local => Duration::from_millis(50),    // Max 20 FPS
+        };
+        
+        Self {
+            run_mode,
+            last_render: Instant::now(),
+            render_scheduled: false,
+            render_scheduled_count: 0,
+            min_render_interval,
+        }
+    }
+    
+    pub fn run_mode(&self) -> RunMode {
+        self.run_mode
+    }
+    
+    pub fn request_render(&mut self, _reason: &str) -> bool {
+        self.render_scheduled_count += 1;
+        
+        let now = Instant::now();
+        let elapsed = now.duration_since(self.last_render);
+        
+        if elapsed >= self.min_render_interval {
+            // Can render immediately
+            self.last_render = now;
+            self.render_scheduled = false;
+            true
+        } else {
+            // Schedule for later
+            self.render_scheduled = true;
+            false
+        }
+    }
+    
+    pub fn should_render(&mut self) -> bool {
+        if !self.render_scheduled {
+            return false;
+        }
+        
+        let now = Instant::now();
+        let elapsed = now.duration_since(self.last_render);
+        
+        if elapsed >= self.min_render_interval {
+            self.last_render = now;
+            self.render_scheduled = false;
+            true
+        } else {
+            false
+        }
+    }
+    
+    pub fn render_scheduled_count(&self) -> u64 {
+        self.render_scheduled_count
+    }
+    
+    pub fn min_render_interval_ms(&self) -> u64 {
+        self.min_render_interval.as_millis() as u64
+    }
+}
+

package/mk3-tui/src/app.rs

@@ -0,0 +1,435 @@
+use crate::io::IoHandler;
+use crossterm::event::{KeyEvent, KeyCode};
+use ratatui::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::collections::VecDeque;
+use std::time::{Duration, Instant};
+
+mod render_scheduler;
+pub use render_scheduler::{RenderScheduler, RunMode};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Message {
+    Log { message: String, ts: String },
+    Posture { status: String },
+    Metrics { cpu: f64, mem: f64 },
+    Network { status: String },
+    Capabilities { items: Vec<String> },
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum AppMode {
+    Boot,
+    Main,
+}
+
+#[derive(Debug, Clone)]
+pub struct AppState {
+    // App mode
+    pub mode: AppMode,
+    
+    // Boot state
+    pub boot_progress: u16,        // 0-100
+    pub boot_lines: VecDeque<String>,
+    pub boot_done: bool,
+    pub boot_started_at: Instant,
+    // Connection state
+    pub connected: bool,
+    #[allow(dead_code)]
+    pub gateway_url: Option<String>,
+    
+    // Real component status
+    #[allow(dead_code)]
+    pub gateway_healthy: bool,
+    pub posture_status: String,
+    pub shield_mode: String,           // "off", "monitor", "enforce"
+    pub shield_detectors: Vec<String>, // ["pii", "injection", "hallucination"]
+    pub sentinel_state: String,        // "idle", "watching", "triggered"
+    pub sentinel_active_runs: usize,
+    
+    // Real metrics
+    pub total_runs: u64,
+    #[allow(dead_code)]
+    pub active_sse_connections: u64,
+    #[allow(dead_code)]
+    pub idempotency_store_size: u64,
+    
+    // System resources
+    pub cpu: f64,
+    pub mem: f64,
+    pub network_status: String,
+    
+    // Real logs
+    pub logs: VecDeque<String>,
+    
+    // Capabilities
+    pub capabilities: Vec<String>,
+    
+    // UI state
+    pub command_input: String,
+    pub command_focused: bool,
+    pub log_scroll: usize,
+    
+    // Animation state
+    pub tick: u64,
+    pub spinner_frame: usize,
+    pub uptime_secs: u64, // Updated from real clock in main loop, not from tick()
+    
+    // Perf overlay
+    pub perf_overlay: bool,
+    pub render_count: u64,
+    pub last_render_time: std::time::Instant,
+    pub render_durations: VecDeque<u64>, // ms
+    pub render_scheduled_count: u64,
+    pub log_write_count: u64,
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self {
+            mode: AppMode::Boot,
+            boot_progress: 0,
+            boot_lines: VecDeque::new(),
+            boot_done: false,
+            boot_started_at: Instant::now(),
+            connected: false,
+            gateway_url: None,
+            gateway_healthy: false,
+            posture_status: "Demo Mode".to_string(),
+            shield_mode: "enforce".to_string(),
+            shield_detectors: vec!["pii".into(), "injection".into(), "hallucination".into()],
+            sentinel_state: "idle".to_string(),
+            sentinel_active_runs: 0,
+            total_runs: 0,
+            active_sse_connections: 0,
+            idempotency_store_size: 0,
+            cpu: 0.15,
+            mem: 0.25,
+            network_status: "Not Connected".to_string(),
+            logs: VecDeque::from([
+                "[SYSTEM] 4Runr AI Agent OS initialized".to_string(),
+                "[SHIELD] Safety layer active (enforce mode)".to_string(),
+                "[SHIELD] Detectors: PII, Injection, Hallucination".to_string(),
+                "[SENTINEL] Real-time monitoring ready".to_string(),
+                "[GATEWAY] Not connected - run with --gateway to connect".to_string(),
+                "[SYSTEM] Type 'help' for available commands".to_string(),
+            ]),
+            capabilities: vec![
+                "text-analysis".to_string(),
+                "code-review".to_string(),
+                "data-extraction".to_string(),
+            ],
+            command_input: String::new(),
+            command_focused: false,
+            log_scroll: 0,
+            tick: 0,
+            spinner_frame: 0,
+            uptime_secs: 0,
+            perf_overlay: false,
+            render_count: 0,
+            last_render_time: std::time::Instant::now(),
+            render_durations: VecDeque::with_capacity(60),
+            render_scheduled_count: 0,
+            log_write_count: 0,
+        }
+    }
+}
+
+pub struct App {
+    pub(crate) state: AppState,
+    render_scheduler: RenderScheduler,
+    pub(crate) input_debounce: Option<Instant>,
+    pub(crate) input_debounce_duration: Duration,
+}
+
+impl App {
+    pub fn new() -> Self {
+        let render_scheduler = RenderScheduler::new();
+        let run_mode = render_scheduler.run_mode();
+        
+        // Input debounce: browser 50ms, local 25ms
+        let input_debounce_duration = match run_mode {
+            RunMode::Browser => Duration::from_millis(50),
+            RunMode::Local => Duration::from_millis(25),
+        };
+        
+        Self {
+            state: AppState::default(),
+            render_scheduler,
+            input_debounce: None,
+            input_debounce_duration,
+        }
+    }
+    
+    pub fn request_render(&mut self, reason: &str) -> bool {
+        self.render_scheduler.request_render(reason)
+    }
+    
+    pub fn should_render(&mut self) -> bool {
+        self.render_scheduler.should_render()
+    }
+    
+    pub fn record_render(&mut self, duration_ms: u64) {
+        self.state.render_count += 1;
+        self.state.render_durations.push_back(duration_ms);
+        if self.state.render_durations.len() > 60 {
+            self.state.render_durations.pop_front();
+        }
+        self.state.last_render_time = Instant::now();
+    }
+    
+    pub fn run_mode(&self) -> RunMode {
+        self.render_scheduler.run_mode()
+    }
+    
+    pub fn render_scheduler_stats(&self) -> (u64, u64) {
+        (
+            self.render_scheduler.render_scheduled_count(),
+            self.render_scheduler.min_render_interval_ms(),
+        )
+    }
+    
+    /// IMPORTANT: Only call tick() when poll() times out (NO keyboard input)!
+    /// Otherwise animations will flash weirdly when typing.
+    /// 
+    /// NOTE: Uptime is now tracked via Instant::now() in main loop,
+    /// so we don't increment it here anymore.
+    pub fn tick(&mut self) {
+        self.state.tick = self.state.tick.wrapping_add(1);
+        
+        // Update spinner frame (for "Processing..." indicator only)
+        // Cycle through 8 braille spinner frames
+        self.state.spinner_frame = (self.state.spinner_frame + 1) % 8;
+        
+        // Boot timeline: update progress every ~150-250ms
+        if self.state.mode == AppMode::Boot && !self.state.boot_done {
+            let elapsed = self.state.boot_started_at.elapsed();
+            let boot_steps = vec![
+                (Duration::from_millis(200), "Initializing gateway…"),
+                (Duration::from_millis(500), "Loading policies…"),
+                (Duration::from_millis(800), "Agent registry online…"),
+                (Duration::from_millis(1100), "Telemetry connected…"),
+                (Duration::from_millis(1400), "System ready."),
+            ];
+            
+            let mut current_progress = 0;
+            let mut step_idx = 0;
+            
+            for (i, (delay, msg)) in boot_steps.iter().enumerate() {
+                if elapsed >= *delay {
+                    step_idx = i + 1;
+                    current_progress = ((i + 1) * 100 / boot_steps.len()) as u16;
+                    
+                    // Add line if not already added
+                    if self.state.boot_lines.len() <= i {
+                        self.state.boot_lines.push_back(msg.to_string());
+                        self.request_render("boot_line");
+                    }
+                }
+            }
+            
+            self.state.boot_progress = current_progress.min(100);
+            
+            // Mark boot done after last step
+            if step_idx >= boot_steps.len() && self.state.boot_progress >= 100 {
+                self.state.boot_done = true;
+                self.request_render("boot_done");
+            }
+        }
+        
+        // NOTE: pulse_frame is NOT updated here - we use static dots for status indicators
+        // to prevent flashing when typing. Only use animated pulse for non-status elements.
+    }
+
+    pub fn handle_input(&mut self, key: KeyEvent, _io: &mut IoHandler) -> anyhow::Result<bool> {
+        use crossterm::event::KeyModifiers;
+        
+        // === EXIT SHORTCUTS (always checked first) ===
+        if key.modifiers.contains(KeyModifiers::CONTROL) {
+            match key.code {
+                KeyCode::Char('c') | KeyCode::Char('q') | KeyCode::Char('d') => {
+                    return Ok(true); // Exit
+                }
+                _ => return Ok(false), // Ignore other Ctrl combos
+            }
+        }
+        
+        if key.code == KeyCode::F(10) {
+            return Ok(true); // Exit
+        }
+        
+        // === BOOT MODE: Any key to continue ===
+        if self.state.mode == AppMode::Boot && self.state.boot_done {
+            // Any key press switches to main dashboard
+            self.state.mode = AppMode::Main;
+            self.request_render("boot_to_main");
+            return Ok(false);
+        }
+        
+        // In boot mode, ignore other input until boot is done
+        if self.state.mode == AppMode::Boot {
+            return Ok(false);
+        }
+        
+        // F12 - Toggle perf overlay
+        if key.code == KeyCode::F(12) {
+            self.state.perf_overlay = !self.state.perf_overlay;
+            self.request_render("perf_toggle");
+            return Ok(false);
+        }
+        
+        // === MAIN INPUT HANDLING ===
+        match key.code {
+            // Typing - ALL characters go to command input (with debounce)
+            KeyCode::Char(c) => {
+                self.state.command_input.push(c);
+                self.state.command_focused = true;
+                // Debounce: schedule render after delay
+                self.input_debounce = Some(Instant::now());
+                // Don't render immediately - let debounce handle it
+            }
+            
+            // Submit command
+            KeyCode::Enter => {
+                if !self.state.command_input.is_empty() {
+                    let cmd: String = self.state.command_input.drain(..).collect();
+                    self.state.command_focused = false;
+                    self.input_debounce = None;
+                    
+                    match cmd.to_lowercase().as_str() {
+                        "quit" | "exit" => return Ok(true),
+                        "clear" => self.state.logs.clear(),
+                        "help" => {
+                            self.state.logs.push_back("[HELP] Commands: quit, exit, clear, help, :perf".into());
+                        }
+                        ":perf" => {
+                            // Perf self-check command
+                            let rps = if !self.state.render_durations.is_empty() {
+                                let avg_ms: f64 = self.state.render_durations.iter().sum::<u64>() as f64 
+                                    / self.state.render_durations.len() as f64;
+                                if avg_ms > 0.0 {
+                                    (1000.0 / avg_ms) as u64
+                                } else {
+                                    0
+                                }
+                            } else {
+                                0
+                            };
+                            
+                            let mode_str = match self.run_mode() {
+                                RunMode::Browser => "browser",
+                                RunMode::Local => "local",
+                            };
+                            
+                            let (scheduled_count, interval_ms) = self.render_scheduler_stats();
+                            
+                            self.state.logs.push_back(format!(
+                                "[PERF] Mode: {} | RPS: {} | Render interval: {}ms | Scheduled: {}",
+                                mode_str,
+                                rps,
+                                interval_ms,
+                                scheduled_count
+                            ));
+                        }
+                        _ => {
+                            self.state.logs.push_back(format!("> {}", cmd));
+                        }
+                    }
+                    self.request_render("command_submit");
+                }
+            }
+            
+            // Delete character
+            KeyCode::Backspace => {
+                self.state.command_input.pop();
+                if self.state.command_input.is_empty() {
+                    self.state.command_focused = false;
+                }
+                // Debounce render
+                self.input_debounce = Some(Instant::now());
+            }
+            
+            // Clear input
+            KeyCode::Esc => {
+                self.state.command_input.clear();
+                self.state.command_focused = false;
+                self.input_debounce = None;
+                self.request_render("clear_input");
+            }
+            
+            // === SCROLL: Arrow keys (only when not typing) ===
+            // Calculate max valid scroll based on visible height
+            KeyCode::Up if self.state.command_input.is_empty() => {
+                let visible_height = 15; // Approximate visible log height (adjust based on actual panel size)
+                let total_logs = self.state.logs.len();
+                let max_scroll = total_logs.saturating_sub(visible_height.max(1));
+                
+                // Clamp scroll to valid range [0, max_scroll]
+                self.state.log_scroll = (self.state.log_scroll + 1).min(max_scroll);
+                self.request_render("scroll_up");
+            }
+            
+            KeyCode::Down if self.state.command_input.is_empty() => {
+                self.state.log_scroll = self.state.log_scroll.saturating_sub(1);
+                self.request_render("scroll_down");
+            }
+            
+            KeyCode::PageUp if self.state.command_input.is_empty() => {
+                let visible_height = 15;
+                let total_logs = self.state.logs.len();
+                let max_scroll = total_logs.saturating_sub(visible_height.max(1));
+                
+                self.state.log_scroll = (self.state.log_scroll + 10).min(max_scroll);
+                self.request_render("scroll_page_up");
+            }
+            
+            KeyCode::PageDown if self.state.command_input.is_empty() => {
+                self.state.log_scroll = self.state.log_scroll.saturating_sub(10);
+                self.request_render("scroll_page_down");
+            }
+            
+            _ => {}
+        }
+        
+        Ok(false)
+    }
+
+    pub fn update(&mut self, message: Message) {
+        match message {
+            Message::Log { message, ts } => {
+                let log_line = format!("[{}] {}", ts, message);
+                self.state.logs.push_back(log_line);
+                if self.state.logs.len() > 1000 {
+                    self.state.logs.pop_front();
+                }
+            }
+            Message::Posture { status } => {
+                self.state.posture_status = status;
+            }
+            Message::Metrics { cpu, mem } => {
+                self.state.cpu = cpu;
+                self.state.mem = mem;
+            }
+            Message::Network { status } => {
+                self.state.network_status = status;
+            }
+            Message::Capabilities { items } => {
+                self.state.capabilities = items;
+            }
+        }
+    }
+
+    pub fn render(&self, f: &mut Frame) {
+        match self.state.mode {
+            AppMode::Boot => {
+                use crate::ui::boot;
+                boot::render_boot(f, f.size(), &self.state);
+            }
+            AppMode::Main => {
+        use crate::ui::layout;
+        layout::render(f, &self.state);
+            }
+        }
+    }
+}
+

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

@@ -0,0 +1,66 @@
+mod protocol;
+mod stdio;
+mod ws;
+
+use crate::app::{App, Message};
+use anyhow::Result;
+use serde_json;
+use std::io::Write;
+use std::sync::mpsc;
+use std::thread;
+
+pub struct IoHandler {
+    receiver: mpsc::Receiver<Message>,
+    #[allow(dead_code)]
+    sender: mpsc::Sender<String>,
+}
+
+impl IoHandler {
+    pub fn new() -> Result<Self> {
+        let (_tx, rx) = mpsc::channel();
+        let (cmd_tx, _cmd_rx) = mpsc::channel();
+
+        // DO NOT spawn any IO threads that read from stdin!
+        // The TUI needs exclusive access to stdin for keyboard input.
+        // Future: use WebSocket or named pipe for backend communication.
+        
+        // Command sender thread (writes to stdout, but doesn't block stdin)
+        thread::spawn(move || {
+            loop {
+                match _cmd_rx.recv() {
+                    Ok(cmd) => {
+                        let cmd_json = serde_json::json!({
+                            "type": "command",
+                            "text": cmd
+                        });
+                        if let Ok(json_str) = serde_json::to_string(&cmd_json) {
+                            println!("{}", json_str);
+                            let _ = std::io::stdout().flush();
+                        }
+                    }
+                    Err(_) => break,
+                }
+            }
+        });
+
+        Ok(Self {
+            receiver: rx,
+            sender: cmd_tx,
+        })
+    }
+
+    pub fn update(&mut self, app: &mut App) -> Result<()> {
+        // Non-blocking receive
+        while let Ok(message) = self.receiver.try_recv() {
+            app.update(message);
+        }
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    pub fn send_command(&mut self, cmd: String) -> Result<()> {
+        self.sender.send(cmd)?;
+        Ok(())
+    }
+}
+

package/mk3-tui/src/io/protocol.rs

@@ -0,0 +1,15 @@
+use crate::app::Message;
+use anyhow::Result;
+use std::sync::mpsc;
+
+#[allow(dead_code)]
+pub trait Protocol: Send {
+    fn run(&mut self) -> Result<()>;
+}
+
+#[allow(dead_code)]
+pub struct ProtocolContext {
+    pub message_tx: mpsc::Sender<Message>,
+    pub command_rx: mpsc::Receiver<String>,
+}
+