4runr-os-mk3 0.1.0 → 0.1.2

package/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/bin/mk3-tui.js

@@ -10,18 +10,32 @@ const __dirname = dirname(__filename);
 
 // Try to find the binary in different locations
 const possiblePaths = [
-  // Development build
+  // From npm package (installed)
   join(__dirname, '..', 'target', 'release', 'mk3-tui'),
   join(__dirname, '..', 'target', 'release', 'mk3-tui.exe'),
-  // Installed binary
-  join(__dirname, 'mk3-tui'),
-  join(__dirname, '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 path of possiblePaths) {
-  if (existsSync(path)) {
-    binaryPath = path;
+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;
   }
 }

package/install.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 
+/**
+ * Post-install script for 4runr-os-mk3
+ * Attempts to build the binary if Rust is available and binary is missing
+ */
+
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { join, dirname } from 'path';
@@ -9,21 +14,42 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const binaryPath = join(__dirname, 'target', 'release', process.platform === 'win32' ? 'mk3-tui.exe' : 'mk3-tui');
+const srcPath = join(__dirname, 'src');
 
-// Check if binary exists, if not, try to build it
-if (!existsSync(binaryPath)) {
-  console.log('mk3-tui binary not found. Building...');
-  try {
-    execSync('cargo build --release', {
-      cwd: __dirname,
-      stdio: 'inherit',
-    });
-    console.log('Build complete!');
-  } catch (error) {
-    console.error('Failed to build mk3-tui. Make sure Rust is installed: https://rustup.rs/');
-    process.exit(1);
-  }
+// Check if binary exists
+if (existsSync(binaryPath)) {
+  console.log('✓ mk3-tui binary found.');
 } else {
-  console.log('mk3-tui binary found.');
+  // Check if Rust source code is available (from npm package)
+  if (existsSync(join(__dirname, 'Cargo.toml')) && existsSync(srcPath)) {
+    // Check if Rust is installed
+    try {
+      execSync('cargo --version', { stdio: 'ignore' });
+      console.log('🔨 Building mk3-tui from source (Rust detected)...');
+      
+      try {
+        execSync('cargo build --release', {
+          cwd: __dirname,
+          stdio: 'inherit',
+        });
+        console.log('✅ Build complete!');
+      } catch (buildError) {
+        console.warn('⚠️  Build failed. The binary will need to be built manually.');
+        console.warn('   Make sure Rust is properly installed: https://rustup.rs/');
+        // Don't exit - let the package install, user can build manually later
+      }
+    } catch {
+      // Rust not installed
+      console.warn('⚠️  mk3-tui binary not found and Rust is not installed.');
+      console.warn('   To build from source, install Rust: https://rustup.rs/');
+      console.warn('   Then run: cd node_modules/4runr-os-mk3 && cargo build --release');
+      // Don't exit - let the package install
+    }
+  } else {
+    // Source code not available
+    console.warn('⚠️  Warning: mk3-tui binary not found.');
+    console.warn('   The binary should be included in the npm package.');
+    console.warn('   If you need to build it manually, install Rust: https://rustup.rs/');
+  }
 }
 

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "4runr-os-mk3",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "4Runr AI Agent OS - Modern Terminal UI (Rust + Ratatui)",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "mk3-tui": "./bin/mk3-tui.js"
+    "mk3-tui": "bin/mk3-tui.js"
   },
   "scripts": {
     "build": "cargo build --release",
-    "install": "node install.js",
+    "postinstall": "node install.js",
     "prepublishOnly": "npm run build"
   },
   "files": [
     "bin/**/*",
+    "src/**/*",
+    "Cargo.toml",
+    "Cargo.lock",
     "target/release/mk3-tui*",
     "install.js",
     "README.md",

package/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/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);
+            }
+        }
+    }
+}
+