feat: add automatic log cleanup after configurable retention period

- Add `logs.retention_days` setting (default: 30 days, 0 = keep forever)
- Add `cleanup_logs_older_than()` to ServerLogManager that walks the
  entire log directory tree removing rotated files older than the
  retention period (both server logs and app-level tracing logs)
- Run cleanup once on app startup and then every 24 hours via a
  background task that reads the current retention setting
- Add Tauri commands `get_log_retention_days` / `set_log_retention_days`
  (setting triggers an immediate cleanup with the new value)
- Add Auto-Cleanup dropdown to the Logs section in Settings UI with
  options: 7, 14, 30, 60, 90 days, or keep forever
- Add unit tests for cleanup logic (retention=0 skip, old file removal,
  app tracing log cleanup, empty directory cleanup)
- Add settings service test for log_retention_days

https://claude.ai/code/session_01V5tgbLyeWrPW5zZ1toRoPZ

Author: claude

Cargo.lock

@@ -1,7 +1,7 @@
 //! Tauri commands for server log management
 
 use crate::state::AppState;
-use mcpmux_core::{LogLevel, ServerLog};
+use mcpmux_core::{AppSettingsService, LogLevel, ServerLog};
 use serde::Serialize;
 use tauri::State;
 use tracing::{info, warn};
@@ -107,3 +107,33 @@ pub async fn get_server_log_file(
 
     Ok(path.to_string_lossy().to_string())
 }
+
+/// Get log retention period in days (0 = keep forever)
+#[tauri::command]
+pub async fn get_log_retention_days(state: State<'_, AppState>) -> Result<u32, String> {
+    let settings = AppSettingsService::new(state.settings_repository.clone());
+    Ok(settings.get_log_retention_days().await)
+}
+
+/// Set log retention period in days (0 = keep forever)
+#[tauri::command]
+pub async fn set_log_retention_days(days: u32, state: State<'_, AppState>) -> Result<(), String> {
+    info!("[Logs] Setting log retention to {} days", days);
+
+    let settings = AppSettingsService::new(state.settings_repository.clone());
+    settings
+        .set_log_retention_days(days)
+        .await
+        .map_err(|e| format!("Failed to save log retention setting: {}", e))?;
+
+    // Run cleanup immediately with the new setting if retention is enabled
+    if days > 0 {
+        match state.server_log_manager.cleanup_logs_older_than(days).await {
+            Ok(n) if n > 0 => info!("[Logs] Cleaned up {} old log file(s)", n),
+            Ok(_) => {}
+            Err(e) => warn!("[Logs] Cleanup after setting change failed: {}", e),
+        }
+    }
+
+    Ok(())
+}

apps/desktop/src-tauri/src/commands/logs.rs

@@ -6,7 +6,7 @@ use mcpmux_core::branding;
 use std::sync::Arc;
 use tauri::{Emitter, Manager};
 use tokio::sync::RwLock;
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 mod commands;
 mod services;
@@ -519,6 +519,53 @@ pub fn run() {
                 });
             }
 
+            // Start periodic log cleanup task
+            {
+                let log_manager = app_state.server_log_manager.clone();
+                let settings_repo_for_cleanup = app_state.settings_repository.clone();
+
+                tauri::async_runtime::spawn(async move {
+                    use mcpmux_core::AppSettingsService;
+
+                    let settings = AppSettingsService::new(settings_repo_for_cleanup);
+
+                    // Run cleanup once at startup
+                    let retention_days = settings.get_log_retention_days().await;
+                    if retention_days > 0 {
+                        info!(
+                            "[LogCleanup] Running startup cleanup (retention: {} days)",
+                            retention_days
+                        );
+                        match log_manager.cleanup_logs_older_than(retention_days).await {
+                            Ok(n) if n > 0 => {
+                                info!("[LogCleanup] Startup cleanup removed {} file(s)", n)
+                            }
+                            Ok(_) => debug!("[LogCleanup] No old log files to clean up"),
+                            Err(e) => warn!("[LogCleanup] Startup cleanup failed: {}", e),
+                        }
+                    }
+
+                    // Then run every 24 hours
+                    let mut interval =
+                        tokio::time::interval(std::time::Duration::from_secs(24 * 60 * 60));
+                    interval.tick().await; // skip the first immediate tick (already ran above)
+
+                    loop {
+                        interval.tick().await;
+                        let days = settings.get_log_retention_days().await;
+                        if days > 0 {
+                            match log_manager.cleanup_logs_older_than(days).await {
+                                Ok(n) if n > 0 => {
+                                    info!("[LogCleanup] Periodic cleanup removed {} file(s)", n)
+                                }
+                                Ok(_) => {}
+                                Err(e) => warn!("[LogCleanup] Periodic cleanup failed: {}", e),
+                            }
+                        }
+                    }
+                });
+            }
+
             // Setup system tray
             tray::setup_tray(app.handle())?;
 
@@ -749,6 +796,8 @@ pub fn run() {
             commands::get_server_logs,
             commands::clear_server_logs,
             commands::get_server_log_file,
+            commands::get_log_retention_days,
+            commands::set_log_retention_days,
             // App log commands
             get_logs_path,
             open_logs_folder,

apps/desktop/src-tauri/src/lib.rs

@@ -21,6 +21,7 @@ import {
   Power,
   Minimize2,
   XCircle,
+  Trash2,
 } from 'lucide-react';
 import { useAppStore, useTheme } from '@/stores';
 import { UpdateChecker } from './UpdateChecker';
@@ -47,6 +48,10 @@ export function SettingsPage() {
   const [loadingSettings, setLoadingSettings] = useState(true);
   const [savingSettings, setSavingSettings] = useState(false);
 
+  // Log retention state
+  const [logRetentionDays, setLogRetentionDays] = useState<number>(30);
+  const [savingRetention, setSavingRetention] = useState(false);
+
   // Load logs path on mount
   useEffect(() => {
     const loadLogsPath = async () => {
@@ -60,6 +65,19 @@ export function SettingsPage() {
     loadLogsPath();
   }, []);
 
+  // Load log retention setting on mount
+  useEffect(() => {
+    const loadRetention = async () => {
+      try {
+        const days = await invoke<number>('get_log_retention_days');
+        setLogRetentionDays(days);
+      } catch (err) {
+        console.error('Failed to load log retention setting:', err);
+      }
+    };
+    loadRetention();
+  }, []);
+
   // Load startup settings on mount
   useEffect(() => {
     const loadStartupSettings = async () => {
@@ -109,6 +127,22 @@ export function SettingsPage() {
     }
   };
 
+  const handleRetentionChange = async (days: number) => {
+    const oldDays = logRetentionDays;
+    setLogRetentionDays(days);
+    setSavingRetention(true);
+    try {
+      await invoke('set_log_retention_days', { days });
+      success('Settings saved', `Log retention set to ${days === 0 ? 'keep forever' : `${days} days`}`);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+      error('Failed to save setting', errorMessage);
+      setLogRetentionDays(oldDays);
+    } finally {
+      setSavingRetention(false);
+    }
+  };
+
   const handleOpenLogs = async () => {
     setOpeningLogs(true);
     try {
@@ -301,6 +335,33 @@ export function SettingsPage() {
                 Open Logs Folder
               </Button>
             </div>
+            <div className="border-t border-[rgb(var(--border))] pt-4">
+              <div className="flex items-center justify-between gap-4">
+                <div className="flex items-start gap-3 flex-1 min-w-0">
+                  <Trash2 className="h-5 w-5 mt-0.5 text-[rgb(var(--muted))] flex-shrink-0" />
+                  <div>
+                    <label className="text-sm font-medium">Auto-Cleanup</label>
+                    <p className="text-xs text-[rgb(var(--muted))] mt-1">
+                      Automatically delete log files older than the selected period
+                    </p>
+                  </div>
+                </div>
+                <select
+                  value={logRetentionDays}
+                  onChange={(e) => handleRetentionChange(Number(e.target.value))}
+                  disabled={savingRetention}
+                  className="px-3 py-1.5 text-sm border border-[rgb(var(--border))] rounded-lg bg-[rgb(var(--surface))] text-[rgb(var(--foreground))]"
+                  data-testid="log-retention-select"
+                >
+                  <option value={7}>7 days</option>
+                  <option value={14}>14 days</option>
+                  <option value={30}>30 days</option>
+                  <option value={60}>60 days</option>
+                  <option value={90}>90 days</option>
+                  <option value={0}>Keep forever</option>
+                </select>
+              </div>
+            </div>
             <p className="text-xs text-[rgb(var(--muted))]">
               Logs are rotated daily. Each file contains detailed debug information including thread IDs and source locations.
             </p>

apps/desktop/src/features/settings/SettingsPage.tsx

@@ -40,3 +40,18 @@ export async function getServerLogFile(serverId: string): Promise<string> {
   return invoke('get_server_log_file', { serverId });
 }
 
+/**
+ * Get log retention period in days (0 = keep forever).
+ */
+export async function getLogRetentionDays(): Promise<number> {
+  return invoke('get_log_retention_days');
+}
+
+/**
+ * Set log retention period in days (0 = keep forever).
+ * Triggers an immediate cleanup with the new setting.
+ */
+export async function setLogRetentionDays(days: number): Promise<void> {
+  return invoke('set_log_retention_days', { days });
+}
+

apps/desktop/src/lib/api/logs.ts

@@ -26,4 +26,5 @@ lazy_static = "1.5"
 [dev-dependencies]
 tokio = { workspace = true, features = ["test-util", "macros"] }
 tempfile = "3.14"
+filetime = "0.2"
 

crates/mcpmux-core/Cargo.toml

@@ -38,6 +38,12 @@ pub mod keys {
         pub const WINDOW_STATE: &str = "ui.window_state";
     }
 
+    /// Logs settings namespace
+    pub mod logs {
+        /// Number of days to retain log files (u32, 0 = keep forever)
+        pub const RETENTION_DAYS: &str = "logs.retention_days";
+    }
+
     /// Registry settings namespace
     pub mod registry {
         /// Cached ETag from last bundle fetch
@@ -236,6 +242,28 @@ impl AppSettingsService {
         self.repository.set(keys::ui::WINDOW_STATE, &json).await
     }
 
+    // =========================================================================
+    // Logs settings
+    // =========================================================================
+
+    /// Default log retention period in days (30 days)
+    pub const DEFAULT_LOG_RETENTION_DAYS: u32 = 30;
+
+    /// Get the log retention period in days (0 = keep forever).
+    pub async fn get_log_retention_days(&self) -> u32 {
+        self.get_typed(keys::logs::RETENTION_DAYS)
+            .await
+            .unwrap_or(Self::DEFAULT_LOG_RETENTION_DAYS)
+    }
+
+    /// Set the log retention period in days.
+    pub async fn set_log_retention_days(&self, days: u32) -> anyhow::Result<()> {
+        info!("[Settings] Setting log retention to {} days", days);
+        self.repository
+            .set(keys::logs::RETENTION_DAYS, &days.to_string())
+            .await
+    }
+
     // =========================================================================
     // Utility methods
     // =========================================================================
@@ -380,4 +408,21 @@ mod tests {
         let loaded: WindowState = service.get_window_state().await;
         assert_eq!(loaded, state);
     }
+
+    #[tokio::test]
+    async fn test_log_retention_days() {
+        let repo = Arc::new(InMemorySettingsRepository::new());
+        let service = AppSettingsService::new(repo);
+
+        // Default is 30 days
+        assert_eq!(service.get_log_retention_days().await, 30);
+
+        // Set to 7 days
+        service.set_log_retention_days(7).await.unwrap();
+        assert_eq!(service.get_log_retention_days().await, 7);
+
+        // Set to 0 (keep forever)
+        service.set_log_retention_days(0).await.unwrap();
+        assert_eq!(service.get_log_retention_days().await, 0);
+    }
 }