4runr-os 2.4.0 → 2.4.1

package/mk3-tui/src/app.rs

@@ -383,8 +383,14 @@ impl App {
                             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());
+                            // 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());
+                            self.state.logs.push_back("  Settings: ↑/↓=Navigate, Space=Toggle, Enter=Save".into());
+                            self.state.logs.push_back("".into());
+                            
+                            // WebSocket Commands - Label BEFORE separator
                             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());
@@ -396,12 +402,6 @@ impl App {
                             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());
-                            self.state.logs.push_back("  Settings: ↑/↓=Navigate, Space=Toggle, Enter=Save".into());
-                            self.state.logs.push_back("".into());
                             self.state.logs.push_back("[HELP] Press F12 to toggle performance overlay".into());
                             self.state.logs.push_back("[HELP] ═══════════════════════════════════════".into());
                         }
@@ -1034,20 +1034,17 @@ impl App {
             // Filter
             KeyCode::Char('f') | KeyCode::Char('F') => {
                 self.state.run_manager.next_filter();
-                self.add_log(format!("[RUN] Filter: {}", self.state.run_manager.filter.as_str()));
                 self.request_render("run_manager_filter");
             }
             
             // Sort
             KeyCode::Char('s') | KeyCode::Char('S') => {
                 self.state.run_manager.next_sort();
-                self.add_log(format!("[RUN] Sort: {}", self.state.run_manager.sort.as_str()));
                 self.request_render("run_manager_sort");
             }
             
             // Refresh
             KeyCode::Char('r') | KeyCode::Char('R') => {
-                self.add_log("[RUN] Refreshing run list...".to_string());
                 // TODO: Send run.list command via WebSocket
                 self.request_render("run_manager_refresh");
             }

package/mk3-tui/src/main.rs

@@ -172,11 +172,14 @@ fn main() -> Result<()> {
                                                 let _ = cache.update_agents(agents);
                                             }
                                             
-                                            app.add_log(format!(
-                                                "✓ [{}] Loaded {} agents",
-                                                short_id,
-                                                agents_array.len()
-                                            ));
+                                            // Only log if agents were actually loaded
+                                            if agents_array.len() > 0 {
+                                                app.add_log(format!(
+                                                    "✓ [{}] Loaded {} agents",
+                                                    short_id,
+                                                    agents_array.len()
+                                                ));
+                                            }
                                         }
                                     } else {
                                         app.add_log(format!("✓ [{}] Success", short_id));

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

@@ -1,213 +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(),
-        })
-    }
-}
+/// 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

@@ -1,6 +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};
+/// Local data storage and caching module
+/// Provides persistent storage for agents, runs, and system status
+
+pub mod cache;
+
+pub use cache::{Cache, CacheData};