4runr-os 2.3.9 → 2.4.0

package/mk3-tui/src/app.rs

@@ -1,5 +1,6 @@
 use crate::io::IoHandler;
 use crate::screens::{NavigationState, Screen};
+use crate::storage::Cache;
 use crate::ui::agent_builder::AgentBuilderState;
 use crate::ui::run_manager::RunManagerState;
 use crate::ui::settings::SettingsState;
@@ -95,6 +96,10 @@ pub struct AppState {
     pub agent_builder: AgentBuilderState,
     pub run_manager: RunManagerState,
     pub settings: SettingsState,
+    
+    // Local cache
+    pub cache: Option<Cache>,
+    pub cache_loaded: bool,
 }
 
 impl Default for AppState {
@@ -148,6 +153,8 @@ impl Default for AppState {
             agent_builder: AgentBuilderState::default(),
             run_manager: RunManagerState::default(),
             settings: SettingsState::default(),
+            cache: Cache::new().ok(),
+            cache_loaded: false,
         }
     }
 }
@@ -170,14 +177,37 @@ impl App {
             RunMode::Local => Duration::from_millis(25),
         };
         
+        let mut state = AppState::default();
+        Self::load_cached_data(&mut state);
+        
         Self {
-            state: AppState::default(),
+            state,
             render_scheduler,
             input_debounce: None,
             input_debounce_duration,
         }
     }
     
+    /// Load cached data on startup
+    fn load_cached_data(state: &mut AppState) {
+        if let Some(cache) = &state.cache {
+            // Load cached agents
+            let agents = cache.get_agents();
+            if !agents.is_empty() {
+                state.capabilities = agents.iter()
+                    .map(|a| a.name.clone())
+                    .collect();
+                state.cache_loaded = true;
+            }
+            
+            // Load cached system status
+            if let Some(status) = cache.get_system_status() {
+                state.network_status = if status.connected { "Connected (cached)".to_string() } else { "Disconnected (cached)".to_string() };
+                state.posture_status = format!("{} (cached)", status.posture);
+            }
+        }
+    }
+    
     pub fn request_render(&mut self, reason: &str) -> bool {
         self.render_scheduler.request_render(reason)
     }
@@ -336,19 +366,27 @@ impl App {
                             self.state.logs.push_back("[HELP] 4Runr AI Agent OS - Command Reference".into());
                             self.state.logs.push_back("[HELP] ═══════════════════════════════════════".into());
                             self.state.logs.push_back("".into());
+                            
+                            // Local Commands
                             self.state.logs.push_back("[HELP] Local Commands:".into());
                             self.state.logs.push_back("  quit, exit       - Exit application".into());
                             self.state.logs.push_back("  clear            - Clear logs".into());
                             self.state.logs.push_back("  help             - Show this help".into());
                             self.state.logs.push_back("  :perf            - Show performance stats".into());
                             self.state.logs.push_back("".into());
+                            
+                            // Navigation Commands
                             self.state.logs.push_back("[HELP] Navigation Commands:".into());
                             self.state.logs.push_back("  build            - Open Agent Builder (6-step wizard)".into());
                             self.state.logs.push_back("  runs             - Open Run Manager (list, filter, sort)".into());
                             self.state.logs.push_back("  config, settings - Open Settings (mode, AI provider)".into());
                             self.state.logs.push_back("  ESC              - Close overlay/popup or clear input".into());
                             self.state.logs.push_back("".into());
+                            
+                            // WebSocket Commands - Label BEFORE commands with clear separator
+                            self.state.logs.push_back("[HELP] ─────────────────────────────────────────".into());
                             self.state.logs.push_back("[HELP] WebSocket Commands (requires connection):".into());
+                            self.state.logs.push_back("[HELP] ─────────────────────────────────────────".into());
                             self.state.logs.push_back("  agent.list       - List all agents".into());
                             self.state.logs.push_back("  agent.get        - Get agent details (data: {name})".into());
                             self.state.logs.push_back("  agent.create     - Create agent (use Agent Builder)".into());
@@ -357,6 +395,8 @@ impl App {
                             self.state.logs.push_back("  run.list         - List runs (requires gateway)".into());
                             self.state.logs.push_back("  tool.list        - List available tools".into());
                             self.state.logs.push_back("".into());
+                            
+                            // Screen Controls
                             self.state.logs.push_back("[HELP] Screen Controls:".into());
                             self.state.logs.push_back("  Agent Builder: Enter=Next, Backspace=Prev, ESC=Cancel".into());
                             self.state.logs.push_back("  Run Manager: ↑/↓=Navigate, F=Filter, S=Sort, R=Refresh".into());
@@ -680,6 +720,29 @@ impl App {
                 self.handle_agent_builder_backspace();
                 self.request_render("agent_builder_backspace");
             }
+            // Left Arrow - go back to previous step
+            KeyCode::Left => {
+                if self.state.agent_builder.current_step > 1 {
+                    self.state.agent_builder.prev_step();
+                    self.add_log("Agent Builder: Moved to previous step".to_string());
+                    self.request_render("agent_builder_prev_step");
+                }
+            }
+            // Right Arrow - move to next step (same as Enter)
+            KeyCode::Right => {
+                if self.state.agent_builder.current_step == 6 {
+                    // Final step - create agent
+                    self.create_agent_from_builder(ws_client);
+                } else {
+                    // Move to next step
+                    if self.state.agent_builder.next_step() {
+                        self.request_render("agent_builder_next");
+                    } else {
+                        // Validation failed - errors are in state
+                        self.request_render("agent_builder_validation");
+                    }
+                }
+            }
             // Tab - move to next field (within step)
             KeyCode::Tab => {
                 let shift = key.modifiers.contains(KeyModifiers::SHIFT);
@@ -989,13 +1052,20 @@ impl App {
                 self.request_render("run_manager_refresh");
             }
             
-            // View details
+            // View details / Close detail view
             KeyCode::Enter => {
-                if let Some(run) = self.state.run_manager.selected_run() {
-                    self.add_log(format!("[RUN] Viewing run: {}", run.name));
-                    // TODO: Open run details overlay
+                if self.state.run_manager.is_detail_view() {
+                    // Close detail view
+                    self.state.run_manager.close_detail_view();
+                    self.add_log("[RUN] Closed detail view".to_string());
                 } else {
-                    self.add_log("[RUN] No run selected".to_string());
+                    // Open detail view
+                    if let Some(run) = self.state.run_manager.selected_run() {
+                        self.add_log(format!("[RUN] Viewing run: {}", run.name));
+                        self.state.run_manager.toggle_detail_view();
+                    } else {
+                        self.add_log("[RUN] No run selected".to_string());
+                    }
                 }
                 self.request_render("run_manager_view");
             }
@@ -1022,9 +1092,17 @@ impl App {
                 self.request_render("run_manager_delete");
             }
             
-            // Close
+            // Close detail view or Run Manager
             KeyCode::Esc => {
-                self.pop_overlay();
+                if self.state.run_manager.is_detail_view() {
+                    // Close detail view
+                    self.state.run_manager.close_detail_view();
+                    self.add_log("[RUN] Closed detail view".to_string());
+                    self.request_render("run_manager_close_detail");
+                } else {
+                    // Close Run Manager
+                    self.pop_overlay();
+                }
             }
             
             _ => {}

package/mk3-tui/src/main.rs

@@ -9,6 +9,7 @@ use std::time::{Duration, Instant};
 mod app;
 mod io;
 mod screens;
+mod storage;
 mod ui;
 mod websocket;
 
@@ -99,7 +100,18 @@ fn main() -> Result<()> {
                         }
                     }
                     WsClientMessage::Disconnected => {
-                        app.add_log("WebSocket disconnected".to_string());
+                        app.add_log("[WEBSOCKET] Disconnected from server".to_string());
+                        app.state.connected = false;
+                    }
+                    WsClientMessage::ConnectionLost => {
+                        app.add_log("[WEBSOCKET] Connection lost - attempting to reconnect...".to_string());
+                        app.state.connected = false;
+                    }
+                    WsClientMessage::Reconnecting => {
+                        app.add_log("[WEBSOCKET] Reconnecting...".to_string());
+                    }
+                    WsClientMessage::ReconnectFailed(reason) => {
+                        app.add_log(format!("[WEBSOCKET] Reconnection failed: {}", reason));
                     }
                     WsClientMessage::Response(resp) => {
                         if resp.payload.success {
@@ -139,6 +151,27 @@ fn main() -> Result<()> {
                                                 })
                                                 .collect();
                                             
+                                            // Update cache with agent data
+                                            if let Some(cache) = &mut app.state.cache {
+                                                use crate::storage::cache::AgentData;
+                                                use std::time::{SystemTime, UNIX_EPOCH};
+                                                
+                                                let agents: Vec<AgentData> = agents_array.iter()
+                                                    .filter_map(|agent| {
+                                                        let obj = agent.as_object()?;
+                                                        Some(AgentData {
+                                                            name: obj.get("name")?.as_str()?.to_string(),
+                                                            description: obj.get("description").and_then(|d| d.as_str()).map(|s| s.to_string()),
+                                                            model: obj.get("model").and_then(|m| m.as_str()).unwrap_or("unknown").to_string(),
+                                                            provider: obj.get("provider").and_then(|p| p.as_str()).unwrap_or("unknown").to_string(),
+                                                            created_at: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+                                                        })
+                                                    })
+                                                    .collect();
+                                                
+                                                let _ = cache.update_agents(agents);
+                                            }
+                                            
                                             app.add_log(format!(
                                                 "✓ [{}] Loaded {} agents",
                                                 short_id,
@@ -156,10 +189,26 @@ fn main() -> Result<()> {
                             }
                         } else {
                             let short_id = &resp.id[resp.id.len().saturating_sub(8)..];
+                            let error_msg = resp.payload.error.unwrap_or_else(|| "Unknown error".to_string());
+                            
+                            // Try to extract command name from response for better error messages
+                            let command_hint = if resp.id.contains("agent") {
+                                " (agent command)"
+                            } else if resp.id.contains("system") {
+                                " (system command)"
+                            } else if resp.id.contains("run") {
+                                " (run command)"
+                            } else if resp.id.contains("tool") {
+                                " (tool command)"
+                            } else {
+                                ""
+                            };
+                            
                             app.add_log(format!(
-                                "✗ [{}] Error: {}",
+                                "✗ [{}]{} Error: {}",
                                 short_id,
-                                resp.payload.error.unwrap_or_default()
+                                command_hint,
+                                error_msg
                             ));
                         }
                     }
@@ -171,7 +220,8 @@ fn main() -> Result<()> {
                         ));
                     }
                     WsClientMessage::Error(err) => {
-                        app.add_log(format!("WebSocket error: {}", err));
+                        app.add_log(format!("[WEBSOCKET] ✗ Error: {}", err));
+                        app.state.connected = false;
                     }
                 }
             }

package/mk3-tui/src/storage/cache.rs

@@ -0,0 +1,213 @@
+/// Cache implementation for local data storage
+/// Stores agents, runs, and system status in JSON format
+
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentData {
+    pub name: String,
+    pub description: Option<String>,
+    pub model: String,
+    pub provider: String,
+    pub created_at: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RunData {
+    pub id: String,
+    pub name: String,
+    pub agent: String,
+    pub status: String,
+    pub started_at: u64,
+    pub duration: Option<u64>,
+    pub tokens_used: Option<u64>,
+    pub cost: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SystemStatusData {
+    pub connected: bool,
+    pub gateway_url: Option<String>,
+    pub posture: String,
+    pub last_updated: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct CacheData {
+    pub agents: Vec<AgentData>,
+    pub runs: Vec<RunData>,
+    pub system_status: Option<SystemStatusData>,
+    pub last_updated: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct Cache {
+    cache_path: PathBuf,
+    data: CacheData,
+}
+
+impl Cache {
+    /// Create a new cache instance
+    pub fn new() -> Result<Self, std::io::Error> {
+        let cache_dir = Self::get_cache_dir()?;
+        fs::create_dir_all(&cache_dir)?;
+        
+        let cache_path = cache_dir.join("4runr_cache.json");
+        let data = Self::load_from_file(&cache_path)?;
+        
+        Ok(Self { cache_path, data })
+    }
+    
+    /// Get the cache directory path
+    fn get_cache_dir() -> Result<PathBuf, std::io::Error> {
+        #[cfg(target_os = "windows")]
+        {
+            let appdata = std::env::var("APPDATA")
+                .unwrap_or_else(|_| String::from("C:\\Users\\Default\\AppData\\Roaming"));
+            Ok(PathBuf::from(appdata).join("4runr"))
+        }
+        
+        #[cfg(not(target_os = "windows"))]
+        {
+            let home = std::env::var("HOME")
+                .unwrap_or_else(|_| String::from("/tmp"));
+            Ok(PathBuf::from(home).join(".4runr"))
+        }
+    }
+    
+    /// Load cache from file
+    fn load_from_file(path: &PathBuf) -> Result<CacheData, std::io::Error> {
+        if !path.exists() {
+            return Ok(CacheData::default());
+        }
+        
+        let contents = fs::read_to_string(path)?;
+        let data: CacheData = serde_json::from_str(&contents)
+            .unwrap_or_default();
+        
+        Ok(data)
+    }
+    
+    /// Save cache to file
+    fn save_to_file(&self) -> Result<(), std::io::Error> {
+        let json = serde_json::to_string_pretty(&self.data)?;
+        fs::write(&self.cache_path, json)?;
+        Ok(())
+    }
+    
+    /// Get current timestamp
+    fn now() -> u64 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    }
+    
+    // === Agent Operations ===
+    
+    /// Get all cached agents
+    pub fn get_agents(&self) -> Vec<AgentData> {
+        self.data.agents.clone()
+    }
+    
+    /// Update agents cache
+    pub fn update_agents(&mut self, agents: Vec<AgentData>) -> Result<(), std::io::Error> {
+        self.data.agents = agents;
+        self.data.last_updated = Self::now();
+        self.save_to_file()
+    }
+    
+    /// Add a single agent
+    pub fn add_agent(&mut self, agent: AgentData) -> Result<(), std::io::Error> {
+        self.data.agents.push(agent);
+        self.data.last_updated = Self::now();
+        self.save_to_file()
+    }
+    
+    /// Remove an agent by name
+    pub fn remove_agent(&mut self, name: &str) -> Result<(), std::io::Error> {
+        self.data.agents.retain(|a| a.name != name);
+        self.data.last_updated = Self::now();
+        self.save_to_file()
+    }
+    
+    // === Run Operations ===
+    
+    /// Get all cached runs
+    pub fn get_runs(&self) -> Vec<RunData> {
+        self.data.runs.clone()
+    }
+    
+    /// Update runs cache
+    pub fn update_runs(&mut self, runs: Vec<RunData>) -> Result<(), std::io::Error> {
+        self.data.runs = runs;
+        self.data.last_updated = Self::now();
+        self.save_to_file()
+    }
+    
+    /// Add a single run
+    pub fn add_run(&mut self, run: RunData) -> Result<(), std::io::Error> {
+        self.data.runs.push(run);
+        self.data.last_updated = Self::now();
+        self.save_to_file()
+    }
+    
+    /// Update a run by ID
+    pub fn update_run(&mut self, id: &str, run: RunData) -> Result<(), std::io::Error> {
+        if let Some(existing) = self.data.runs.iter_mut().find(|r| r.id == id) {
+            *existing = run;
+            self.data.last_updated = Self::now();
+            self.save_to_file()?;
+        }
+        Ok(())
+    }
+    
+    // === System Status Operations ===
+    
+    /// Get cached system status
+    pub fn get_system_status(&self) -> Option<SystemStatusData> {
+        self.data.system_status.clone()
+    }
+    
+    /// Update system status cache
+    pub fn update_system_status(&mut self, status: SystemStatusData) -> Result<(), std::io::Error> {
+        self.data.system_status = Some(status);
+        self.data.last_updated = Self::now();
+        self.save_to_file()
+    }
+    
+    // === Cache Management ===
+    
+    /// Get cache age in seconds
+    pub fn get_age(&self) -> u64 {
+        Self::now().saturating_sub(self.data.last_updated)
+    }
+    
+    /// Check if cache is stale (older than threshold)
+    pub fn is_stale(&self, threshold_secs: u64) -> bool {
+        self.get_age() > threshold_secs
+    }
+    
+    /// Clear all cached data
+    pub fn clear(&mut self) -> Result<(), std::io::Error> {
+        self.data = CacheData::default();
+        self.save_to_file()
+    }
+    
+    /// Get cache data reference
+    pub fn data(&self) -> &CacheData {
+        &self.data
+    }
+}
+
+impl Default for Cache {
+    fn default() -> Self {
+        Self::new().unwrap_or_else(|_| Self {
+            cache_path: PathBuf::from("4runr_cache.json"),
+            data: CacheData::default(),
+        })
+    }
+}

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

@@ -0,0 +1,6 @@
+/// Local data storage and caching module
+/// Provides persistent storage for agents, runs, and system status
+
+pub mod cache;
+
+pub use cache::{Cache, CacheData};