fix: Improve cache cleanup, error sanitization, and log batching

- cache.rs: Add cleanup_expired() call to pgrep cache functions to ensure
  all cache entries are periodically cleaned up
- cli.rs: Sanitize error messages to avoid exposing sensitive system
  details; log full errors for debugging, return user-friendly messages
- log.rs: Batch log lines into single event emission to reduce IPC
  overhead and improve UI performance
- constants.ts, logs.ts: Update frontend to handle batched log-lines event

Author: fenio

src-tauri/src/cache.rs

@@ -122,8 +122,9 @@ pub fn get_mount_output() -> Option<Output> {
 pub fn is_krun_running() -> bool {
     let cache_key = "pgrep_krun".to_string();
 
-    // Check cache first
+    // Check cache first (also cleanup expired entries periodically)
     let cached = with_cache(|cache| {
+        cache.cleanup_expired(MAX_CACHE_AGE);
         cache.get(&cache_key, PGREP_CACHE_DURATION).cloned()
     }).flatten();
 
@@ -147,8 +148,9 @@ pub fn is_krun_running() -> bool {
 pub fn is_libkrun_running() -> bool {
     let cache_key = "pgrep_libkrun".to_string();
 
-    // Check cache first
+    // Check cache first (also cleanup expired entries periodically)
     let cached = with_cache(|cache| {
+        cache.cleanup_expired(MAX_CACHE_AGE);
         cache.get(&cache_key, PGREP_CACHE_DURATION).cloned()
     }).flatten();
 

src-tauri/src/cli.rs

@@ -5,6 +5,50 @@ use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
 use std::sync::OnceLock;
 
+/// Sanitize error output to avoid exposing sensitive system details
+/// Logs the full error for debugging but returns a user-friendly message
+fn sanitize_error(stdout: &str, stderr: &str) -> String {
+    // Log full details for debugging
+    if !stdout.is_empty() || !stderr.is_empty() {
+        log::debug!("Command failed - stdout: {}, stderr: {}", stdout, stderr);
+    }
+
+    // Check for common error patterns and return user-friendly messages
+    let combined = format!("{}{}", stdout, stderr);
+
+    if combined.contains("not mounted") || combined.contains("No such file") {
+        return "Filesystem is not mounted".to_string();
+    }
+    if combined.contains("Permission denied") {
+        return "Permission denied - try running with administrator privileges".to_string();
+    }
+    if combined.contains("Device busy") || combined.contains("resource busy") {
+        return "Device is busy - close any applications using it and try again".to_string();
+    }
+    if combined.contains("Invalid argument") {
+        return "Invalid operation or unsupported filesystem".to_string();
+    }
+    if combined.contains("No space left") {
+        return "No space left on device".to_string();
+    }
+    if combined.contains("Read-only") {
+        return "Filesystem is read-only".to_string();
+    }
+
+    // For anylinuxfs-specific errors, extract the message after "Error:"
+    if let Some(pos) = combined.find("Error:") {
+        let error_msg = combined[pos + 6..].trim();
+        // Take first line only, limit length
+        let first_line = error_msg.lines().next().unwrap_or(error_msg);
+        if first_line.len() <= 200 {
+            return first_line.to_string();
+        }
+    }
+
+    // Generic fallback - don't expose raw output
+    "Operation failed - check logs for details".to_string()
+}
+
 /// Common locations to search for anylinuxfs
 const SEARCH_PATHS: &[&str] = &[
     "/opt/homebrew/bin/anylinuxfs",
@@ -115,7 +159,7 @@ fn execute_direct(args: &[&str], passphrase: Option<&str>) -> Result<String, Str
     } else {
         let stderr = String::from_utf8_lossy(&output.stderr);
         let stdout = String::from_utf8_lossy(&output.stdout);
-        Err(format!("{}{}", stdout, stderr))
+        Err(sanitize_error(&stdout, &stderr))
     }
 }
 
@@ -177,7 +221,7 @@ fn execute_with_sudo(args: &[&str], passphrase: Option<&str>) -> Result<String,
                     } else if stderr.contains("no askpass program") || stderr.contains("no password was provided") {
                         return Err("Authentication cancelled".to_string());
                     } else {
-                        return Err(format!("{}{}", stdout, stderr));
+                        return Err(sanitize_error(&stdout, &stderr));
                     }
                 }
             }

src-tauri/src/commands/log.rs

@@ -115,7 +115,7 @@ pub fn start_log_stream(app: AppHandle) -> Result<(), String> {
                     if is_our_file {
                         match event.kind {
                             EventKind::Modify(_) | EventKind::Create(_) => {
-                                // Read new lines
+                                // Read new lines and batch them
                                 if let Ok(mut file) = File::open(&log_path) {
                                     let file_len = file.metadata()
                                         .map(|m| m.len())
@@ -124,21 +124,25 @@ pub fn start_log_stream(app: AppHandle) -> Result<(), String> {
                                     if file_len > last_pos {
                                         if file.seek(SeekFrom::Start(last_pos)).is_ok() {
                                             let reader = BufReader::new(&file);
-                                            for line in reader.lines() {
-                                                if let Ok(line) = line {
-                                                    let _ = app.emit("log-line", line);
-                                                }
+                                            // Batch lines to reduce IPC overhead
+                                            let lines: Vec<String> = reader.lines()
+                                                .filter_map(|l| l.ok())
+                                                .collect();
+                                            if !lines.is_empty() {
+                                                let _ = app.emit("log-lines", lines);
                                             }
                                         }
                                         last_pos = file_len;
                                     } else if file_len < last_pos {
                                         // File was truncated, read from beginning
                                         if file.seek(SeekFrom::Start(0)).is_ok() {
                                             let reader = BufReader::new(&file);
-                                            for line in reader.lines() {
-                                                if let Ok(line) = line {
-                                                    let _ = app.emit("log-line", line);
-                                                }
+                                            // Batch lines to reduce IPC overhead
+                                            let lines: Vec<String> = reader.lines()
+                                                .filter_map(|l| l.ok())
+                                                .collect();
+                                            if !lines.is_empty() {
+                                                let _ = app.emit("log-lines", lines);
                                             }
                                         }
                                         last_pos = file_len;

src/lib/constants.ts

@@ -1,6 +1,6 @@
 // Tauri event names
 export const Events = {
-	LOG_LINE: 'log-line',
+	LOG_LINES: 'log-lines', // Batched log lines for better performance
 	SHELL_OUTPUT: 'shell-output',
 	SHELL_EXIT: 'shell-exit',
 	DISKS_CHANGED: 'disks-changed',

src/lib/stores/logs.ts

@@ -55,11 +55,13 @@ function createLogsStore() {
 				// Start the backend log watcher
 				await startLogStream();
 
-				// Listen for log events
-				unlisten = await listen<string>(Events.LOG_LINE, (event) => {
+				// Listen for batched log events (more efficient than per-line)
+				unlisten = await listen<string[]>(Events.LOG_LINES, (event) => {
 					update((s) => {
-						const newLine = processLine(event.payload);
-						const newLines = [...s.lines, newLine];
+						const newLines = [...s.lines];
+						for (const line of event.payload) {
+							newLines.push(processLine(line));
+						}
 						// Keep only last MAX_LINES
 						if (newLines.length > Limits.MAX_LOG_LINES) {
 							newLines.splice(0, newLines.length - Limits.MAX_LOG_LINES);