Wire up all settings to actual functionality

- Add cross-window settings sync via Tauri events (settings:changed)
- Create reactive-settings.svelte.ts for immediate UI updates
- Wire UI density to row heights in BriefList/FullList
- Wire date/time format with live formatting updates
- Wire file size format (binary/SI) throughout the app
- Wire network timeout settings to SMB client operations
- Wire developer settings (verbose logging, MCP config)
- Wire advanced settings (virtualization buffer, debounce, timeouts)
- Fix Reset feature not clearing modified indicators
- Fix app icons toggle causing missing icons (cache refresh)
- Fix BriefList bottom bar to use reactive file size format
- Add format-utils.ts for pure formatting functions
- Add network-settings.ts helpers for timeout calculations
- Add settings-applier.ts for CSS variable and backend sync

Author: vdavid

apps/desktop/coverage-allowlist.json

@@ -34,6 +34,7 @@
         "settings/components/SettingRadioGroup.svelte": { "reason": "UI component, logic is simple" },
         "settings/components/SectionSummary.svelte": { "reason": "UI component, simple navigation cards" },
         "settings/format-utils.ts": { "reason": "Simple date formatting, low complexity" },
+        "settings/network-settings.ts": { "reason": "Thin wrapper over getSetting, requires mocking settings store" },
         "settings/reactive-settings.svelte.ts": { "reason": "Svelte reactive state, depends on settings store" },
         "settings/settings-applier.ts": { "reason": "Depends on DOM APIs (document.documentElement.style)" },
         "settings/components/SettingRow.svelte": { "reason": "UI component, layout only" },

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

@@ -392,7 +392,7 @@ pub fn cancel_write_operation(operation_id: String, rollback: bool) {
 /// the actual copy operation.
 ///
 /// # Events emitted
-/// * `scan-preview-progress` - Every 100ms with current counts
+/// * `scan-preview-progress` - Based on progress_interval_ms setting
 /// * `scan-preview-complete` - When scanning finishes
 /// * `scan-preview-error` - On error
 /// * `scan-preview-cancelled` - If cancelled
@@ -402,15 +402,18 @@ pub fn cancel_write_operation(operation_id: String, rollback: bool) {
 /// * `sources` - List of source file/directory paths. Supports tilde expansion (~).
 /// * `sort_column` - Column to sort files by.
 /// * `sort_order` - Sort order (ascending/descending).
+/// * `progress_interval_ms` - Progress update interval in milliseconds (default: 500).
 #[tauri::command]
 pub fn start_scan_preview(
     app: tauri::AppHandle,
     sources: Vec<String>,
     sort_column: SortColumn,
     sort_order: SortOrder,
+    progress_interval_ms: Option<u64>,
 ) -> ScanPreviewStartResult {
     let sources: Vec<PathBuf> = sources.iter().map(|s| PathBuf::from(expand_tilde(s))).collect();
-    ops_start_scan_preview(app, sources, sort_column, sort_order)
+    let progress_interval = progress_interval_ms.unwrap_or(500);
+    ops_start_scan_preview(app, sources, sort_column, sort_order, progress_interval)
 }
 
 /// Cancels a running scan preview.

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

@@ -7,6 +7,7 @@ pub mod icons;
 pub mod licensing;
 #[cfg(target_os = "macos")]
 pub mod network;
+pub mod settings;
 pub mod sync_status; // Has both macOS and non-macOS implementations
 pub mod ui;
 #[cfg(target_os = "macos")]

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

@@ -59,31 +59,60 @@ pub async fn resolve_host(host_id: String) -> Option<NetworkHost> {
 
 /// Lists shares available on a network host.
 ///
-/// Returns cached results if available (30 second TTL), otherwise queries the host.
+/// Returns cached results if available, otherwise queries the host.
 /// Attempts guest access first; returns an error if authentication is required.
 ///
 /// # Arguments
 /// * `host_id` - Unique identifier for the host (used for caching)
 /// * `hostname` - Hostname to connect to (for example, "TEST_SERVER.local")
 /// * `ip_address` - Optional resolved IP address (preferred over hostname for reliability)
 /// * `port` - SMB port (default 445, but Docker containers may use different ports)
+/// * `timeout_ms` - Optional timeout in milliseconds (default: 15000)
+/// * `cache_ttl_ms` - Optional cache TTL in milliseconds (default: 30000)
 #[tauri::command]
 pub async fn list_shares_on_host(
     host_id: String,
     hostname: String,
     ip_address: Option<String>,
     port: u16,
+    timeout_ms: Option<u64>,
+    cache_ttl_ms: Option<u64>,
 ) -> Result<ShareListResult, ShareListError> {
-    smb_client::list_shares(&host_id, &hostname, ip_address.as_deref(), port, None).await
+    smb_client::list_shares(
+        &host_id,
+        &hostname,
+        ip_address.as_deref(),
+        port,
+        None,
+        timeout_ms,
+        cache_ttl_ms,
+    )
+    .await
 }
 
 /// Prefetches shares for a host (for example, on hover).
 /// Same as list_shares_on_host but designed for prefetching - errors are silently ignored.
 /// Returns immediately if shares are already cached.
 #[tauri::command]
-pub async fn prefetch_shares(host_id: String, hostname: String, ip_address: Option<String>, port: u16) {
+pub async fn prefetch_shares(
+    host_id: String,
+    hostname: String,
+    ip_address: Option<String>,
+    port: u16,
+    timeout_ms: Option<u64>,
+    cache_ttl_ms: Option<u64>,
+) {
     // Fire and forget - we don't care about the result for prefetching
-    let _ = smb_client::list_shares(&host_id, &hostname, ip_address.as_deref(), port, None).await;
+    let _ = smb_client::list_shares(
+        &host_id,
+        &hostname,
+        ip_address.as_deref(),
+        port,
+        None,
+        timeout_ms,
+        cache_ttl_ms,
+    )
+    .await;
 }
 
 /// Gets auth mode detected for a host (from cached share list if available).
@@ -189,14 +218,22 @@ pub fn delete_smb_credentials(server: String, share: Option<String>) -> Result<(
 /// * `port` - SMB port
 /// * `username` - Username for authentication (or None for guest)
 /// * `password` - Password for authentication (or None for guest)
+/// * `timeout_ms` - Optional timeout in milliseconds (default: 15000)
+/// * `cache_ttl_ms` - Optional cache TTL in milliseconds (default: 30000)
 #[tauri::command]
+#[allow(
+    clippy::too_many_arguments,
+    reason = "Tauri command requires all parameters to be top-level"
+)]
 pub async fn list_shares_with_credentials(
     host_id: String,
     hostname: String,
     ip_address: Option<String>,
     port: u16,
     username: Option<String>,
     password: Option<String>,
+    timeout_ms: Option<u64>,
+    cache_ttl_ms: Option<u64>,
 ) -> Result<ShareListResult, ShareListError> {
     let credentials = match (username, password) {
         (Some(u), Some(p)) => Some((u, p)),
@@ -209,6 +246,8 @@ pub async fn list_shares_with_credentials(
         ip_address.as_deref(),
         port,
         credentials.as_ref().map(|(u, p)| (u.as_str(), p.as_str())),
+        timeout_ms,
+        cache_ttl_ms,
     )
     .await
 }
@@ -228,6 +267,7 @@ use crate::network::mount::{self, MountError, MountResult};
 /// * `share` - Name of the share to mount
 /// * `username` - Optional username for authentication
 /// * `password` - Optional password for authentication
+/// * `timeout_ms` - Optional timeout in milliseconds (default: 20000)
 ///
 /// # Returns
 /// * `Ok(MountResult)` - Mount successful, with path to mount point
@@ -238,6 +278,7 @@ pub async fn mount_network_share(
     share: String,
     username: Option<String>,
     password: Option<String>,
+    timeout_ms: Option<u64>,
 ) -> Result<MountResult, MountError> {
-    mount::mount_share(server, share, username, password).await
+    mount::mount_share(server, share, username, password, timeout_ms).await
 }

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

@@ -0,0 +1,75 @@
+//! Settings-related commands.
+
+use std::net::TcpListener;
+
+use crate::file_system::update_debounce_ms;
+#[cfg(target_os = "macos")]
+use crate::network::bonjour::update_resolve_timeout;
+
+/// Check if a port is available for binding.
+#[tauri::command]
+pub fn check_port_available(port: u16) -> bool {
+    TcpListener::bind(("127.0.0.1", port)).is_ok()
+}
+
+/// Find an available port starting from the given port.
+/// Scans up to 100 ports from the start port.
+#[tauri::command]
+pub fn find_available_port(start_port: u16) -> Option<u16> {
+    for offset in 0..100 {
+        let port = start_port.saturating_add(offset);
+        if check_port_available(port) {
+            return Some(port);
+        }
+    }
+    None
+}
+
+/// Updates the file watcher debounce duration in milliseconds.
+/// This affects newly created watchers; existing watchers keep their original duration.
+#[tauri::command]
+pub fn update_file_watcher_debounce(debounce_ms: u64) {
+    update_debounce_ms(debounce_ms);
+}
+
+/// Updates the Bonjour service resolve timeout in milliseconds.
+/// This affects future service resolutions; ongoing resolutions keep their original timeout.
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub fn update_service_resolve_timeout(timeout_ms: u64) {
+    update_resolve_timeout(timeout_ms);
+}
+
+/// Stub for non-macOS platforms - network discovery is not supported.
+#[cfg(not(target_os = "macos"))]
+#[tauri::command]
+pub fn update_service_resolve_timeout(_timeout_ms: u64) {
+    // No-op on non-macOS platforms
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_check_port_available() {
+        // Port 0 should let OS pick an available port, so this should succeed
+        // But we test a high port that's likely free
+        let result = check_port_available(49999);
+        // The function should return a valid boolean (either true or false)
+        // This test verifies the function executes without panic
+        let _ = result;
+    }
+
+    #[test]
+    fn test_find_available_port() {
+        // Should find some available port
+        let result = find_available_port(49000);
+        // On most systems, we should find an available port in the high range
+        assert!(result.is_some());
+        if let Some(port) = result {
+            assert!(port >= 49000);
+            assert!(port < 49100);
+        }
+    }
+}

apps/desktop/src-tauri/src/file_system/mod.rs

@@ -41,7 +41,7 @@ pub use volume::{InMemoryVolume, LocalPosixVolume, Volume, VolumeError};
 #[allow(unused_imports, reason = "Public API re-exports for future use")]
 pub use volume_manager::VolumeManager;
 // Watcher management - init_watcher_manager must be called from lib.rs
-pub use watcher::init_watcher_manager;
+pub use watcher::{init_watcher_manager, update_debounce_ms};
 // Re-export write operation types
 pub use write_operations::{
     OperationStatus, OperationSummary, WriteOperationConfig, WriteOperationError, WriteOperationStartResult,

apps/desktop/src-tauri/src/file_system/watcher.rs

@@ -16,8 +16,23 @@ use tauri::{AppHandle, Emitter};
 
 use super::operations::{FileEntry, get_listing_entries, list_directory_core, update_listing_entries};
 
-/// Debounce duration in milliseconds
-const DEBOUNCE_MS: u64 = 200;
+/// Default debounce duration in milliseconds (used if not configured)
+const DEFAULT_DEBOUNCE_MS: u64 = 200;
+
+/// Configured debounce duration in milliseconds (set by frontend via update_debounce_ms)
+static DEBOUNCE_MS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(DEFAULT_DEBOUNCE_MS);
+
+/// Updates the file watcher debounce duration.
+/// This affects newly started watchers; existing watchers keep their original duration.
+pub fn update_debounce_ms(ms: u64) {
+    DEBOUNCE_MS.store(ms, std::sync::atomic::Ordering::Relaxed);
+    log::debug!("File watcher debounce updated to {} ms", ms);
+}
+
+/// Gets the current debounce duration in milliseconds.
+fn get_debounce_ms() -> u64 {
+    DEBOUNCE_MS.load(std::sync::atomic::Ordering::Relaxed)
+}
 
 /// Global watcher manager
 static WATCHER_MANAGER: LazyLock<RwLock<WatcherManager>> = LazyLock::new(|| RwLock::new(WatcherManager::new()));
@@ -88,8 +103,9 @@ pub fn start_watching(listing_id: &str, path: &Path) -> Result<(), String> {
     let listing_for_closure = listing_id_owned.clone();
 
     // Create the debouncer with a callback that handles changes
+    let debounce_duration = Duration::from_millis(get_debounce_ms());
     let mut debouncer = new_debouncer(
-        Duration::from_millis(DEBOUNCE_MS),
+        debounce_duration,
         None, // No tick rate limit
         move |result: DebounceEventResult| {
             if let Ok(_events) = result {

apps/desktop/src-tauri/src/file_system/write_operations/copy.rs

@@ -52,6 +52,7 @@ pub(super) fn copy_files_with_progress(
         operation_id,
         WriteOperationType::Copy,
         state.progress_interval,
+        config.max_conflicts_to_show,
     )? {
         return Ok(());
     }

apps/desktop/src-tauri/src/file_system/write_operations/move_op.rs

@@ -37,6 +37,7 @@ pub(super) fn move_files_with_progress(
         operation_id,
         WriteOperationType::Move,
         state.progress_interval,
+        config.max_conflicts_to_show,
     )? {
         return Ok(());
     }

apps/desktop/src-tauri/src/file_system/write_operations/scan.rs

@@ -16,9 +16,9 @@ use super::state::{
     WriteOperationState, update_operation_status,
 };
 use super::types::{
-    ConflictInfo, MAX_CONFLICTS_IN_RESULT, ScanPreviewCancelledEvent, ScanPreviewCompleteEvent, ScanPreviewErrorEvent,
-    ScanPreviewProgressEvent, ScanPreviewStartResult, ScanProgressEvent, SortColumn, SortOrder, WriteOperationError,
-    WriteOperationPhase, WriteOperationType, WriteProgressEvent,
+    ConflictInfo, ScanPreviewCancelledEvent, ScanPreviewCompleteEvent, ScanPreviewErrorEvent, ScanPreviewProgressEvent,
+    ScanPreviewStartResult, ScanProgressEvent, SortColumn, SortOrder, WriteOperationError, WriteOperationPhase,
+    WriteOperationType, WriteProgressEvent,
 };
 
 // ============================================================================
@@ -32,13 +32,14 @@ pub fn start_scan_preview(
     sources: Vec<PathBuf>,
     sort_column: SortColumn,
     sort_order: SortOrder,
+    progress_interval_ms: u64,
 ) -> ScanPreviewStartResult {
     let preview_id = Uuid::new_v4().to_string();
     let preview_id_clone = preview_id.clone();
 
     let state = Arc::new(ScanPreviewState {
         cancelled: AtomicBool::new(false),
-        progress_interval: Duration::from_millis(100),
+        progress_interval: Duration::from_millis(progress_interval_ms),
     });
 
     // Register state
@@ -668,6 +669,7 @@ pub(super) fn handle_dry_run(
     operation_id: &str,
     operation_type: WriteOperationType,
     progress_interval: Duration,
+    max_conflicts_to_show: usize,
 ) -> Result<bool, WriteOperationError> {
     use super::types::DryRunResult;
     use tauri::Emitter;
@@ -687,7 +689,7 @@ pub(super) fn handle_dry_run(
     )?;
 
     let conflicts_count = scan_result.conflicts.len();
-    let (sampled_conflicts, conflicts_sampled) = sample_conflicts(scan_result.conflicts, MAX_CONFLICTS_IN_RESULT);
+    let (sampled_conflicts, conflicts_sampled) = sample_conflicts(scan_result.conflicts, max_conflicts_to_show);
 
     let result = DryRunResult {
         operation_id: operation_id.to_string(),