MTP: Add settings toggle to disable MTP

- Add `fileOperations.mtpEnabled` setting (Settings > General > File operations) to enable/disable Android device support
- `MTP_ENABLED` `AtomicBool` gate in `watcher.rs` — watcher loop keeps running but skips auto-connect when disabled
- `set_mtp_enabled()` async: disconnects all devices, clears `KNOWN_DEVICES`, restores `ptpcamerad` (macOS)
- `set_mtp_enabled_flag()` sync: sets the flag at startup before `start_mtp_watcher()`
- Moved `load_settings()` earlier in `lib.rs` so the flag is set before the watcher auto-connects
- Frontend: registry entry, `SettingSwitch` in `FileOperationsSection`, `settings-applier.ts` dispatch
- Takes effect instantly — no restart needed

Author: vdavid

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

@@ -22,6 +22,16 @@ pub struct MtpScanResult {
     pub total_bytes: u64,
 }
 
+/// Enables or disables MTP support at runtime.
+///
+/// When disabled: disconnects all devices, stops auto-connecting, and restores
+/// ptpcamerad (macOS). When enabled: resumes auto-connecting and checks for
+/// already-plugged-in devices.
+#[tauri::command]
+pub async fn set_mtp_enabled(enabled: bool) {
+    mtp::set_mtp_enabled(enabled).await;
+}
+
 /// Lists all connected MTP devices.
 ///
 /// This returns devices detected via USB that support MTP protocol.

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

@@ -329,6 +329,13 @@ pub fn run() {
             #[cfg(target_os = "macos")]
             mtp::macos_workaround::ensure_ptpcamerad_enabled();
 
+            // Load persisted settings early so MTP enabled flag is set before the watcher starts
+            let saved_settings = settings::load_settings(app.handle());
+
+            // Apply MTP enabled setting (default: true) before starting the watcher
+            #[cfg(any(target_os = "macos", target_os = "linux"))]
+            mtp::set_mtp_enabled_flag(saved_settings.mtp_enabled.unwrap_or(true));
+
             // Start MTP device hotplug watcher (Android device support)
             // This also auto-connects any devices already plugged in at startup
             #[cfg(any(target_os = "macos", target_os = "linux"))]
@@ -355,9 +362,6 @@ pub fn run() {
             // Initialize font metrics for default font (system font at 12px)
             font_metrics::init_font_metrics(app.handle(), "system-400-12");
 
-            // Load persisted settings to initialize menu with correct state
-            let saved_settings = settings::load_settings(app.handle());
-
             // Apply direct SMB connection setting (default: true)
             file_system::set_direct_smb_enabled(saved_settings.direct_smb_connection.unwrap_or(true));
 
@@ -691,6 +695,8 @@ pub fn run() {
             commands::sync_status::get_sync_status,
             // MTP commands (macOS + Linux - Android device support)
             #[cfg(any(target_os = "macos", target_os = "linux"))]
+            commands::mtp::set_mtp_enabled,
+            #[cfg(any(target_os = "macos", target_os = "linux"))]
             commands::mtp::list_mtp_devices,
             #[cfg(any(target_os = "macos", target_os = "linux"))]
             commands::mtp::connect_mtp_device,
@@ -725,6 +731,8 @@ pub fn run() {
             #[cfg(feature = "virtual-mtp")]
             commands::mtp::resume_virtual_mtp_watcher,
             #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+            stubs::mtp::set_mtp_enabled,
+            #[cfg(not(any(target_os = "macos", target_os = "linux")))]
             stubs::mtp::list_mtp_devices,
             #[cfg(not(any(target_os = "macos", target_os = "linux")))]
             stubs::mtp::connect_mtp_device,

apps/desktop/src-tauri/src/mtp/CLAUDE.md

@@ -29,6 +29,7 @@ On Linux, users may need udev rules for USB device permissions (see `resources/9
 USB plug-in
   → nusb hotplug event (watcher.rs)
   → 500 ms delay
+  → check MTP_ENABLED gate — skip if disabled
   → list_mtp_devices() (discovery.rs)
   → auto_connect_device() (watcher.rs)
     → MtpConnectionManager::connect()
@@ -52,6 +53,15 @@ Event loop (event_loop.rs)
   → emit directory-diff (same format as local file watching)
 ```
 
+### MTP enabled/disabled toggle
+
+`MTP_ENABLED` (`AtomicBool`, default `true`) in `watcher.rs` gates all auto-connect behavior. The watcher loop always runs (it's `OnceLock`-based, no shutdown channel), but `check_for_device_changes()` returns early when disabled.
+
+- **`set_mtp_enabled_flag(bool)`** — Sets the flag without side effects. Called at startup from `lib.rs` before `start_mtp_watcher()` so the initial auto-connect respects the persisted setting.
+- **`set_mtp_enabled(bool, app)`** — Async. Called at runtime via the `set_mtp_enabled` Tauri command. When disabling: disconnects all devices, clears `KNOWN_DEVICES`, restores ptpcamerad (macOS). When enabling: calls `check_for_device_changes()` to pick up already-plugged devices.
+- **Setting key**: `fileOperations.mtpEnabled` in `settings.json`, read by `settings/loader.rs` at startup.
+- **Interaction with ptpcamerad**: disabling MTP calls `restore_ptpcamerad_unconditionally()`. Re-enabling triggers auto-connect, which re-suppresses ptpcamerad if devices are found.
+
 The frontend is a passive consumer: it subscribes to `volumes-changed` (for the volume picker)
 and `mtp-device-connected`/`mtp-device-disconnected` (for device connection state tracking).
 It never orchestrates MTP connections.

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

@@ -30,7 +30,7 @@ pub mod watcher;
 pub use connection::{ConnectedDeviceInfo, MtpConnectionError, MtpObjectInfo, MtpOperationResult, connection_manager};
 pub use discovery::list_mtp_devices;
 pub use types::{MtpDeviceInfo, MtpStorageInfo};
-pub use watcher::start_mtp_watcher;
+pub use watcher::{set_mtp_enabled, set_mtp_enabled_flag, start_mtp_watcher};
 
 /// The Terminal command that users can run to work around ptpcamerad on macOS.
 /// Returns an empty string on non-macOS platforms (ptpcamerad doesn't exist there).

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

@@ -8,6 +8,7 @@
 use log::{debug, error, info, warn};
 use nusb::hotplug::HotplugEvent;
 use std::collections::HashSet;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Mutex, OnceLock};
 use tauri::AppHandle;
 
@@ -20,6 +21,55 @@ static KNOWN_DEVICES: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();
 /// Flag to indicate watcher has been started
 static WATCHER_STARTED: OnceLock<()> = OnceLock::new();
 
+/// Whether MTP support is enabled. When false, the watcher loop still runs
+/// but `check_for_device_changes()` returns early and no auto-connects happen.
+static MTP_ENABLED: AtomicBool = AtomicBool::new(true);
+
+/// Sets the MTP enabled flag without side effects. Used at startup before the
+/// watcher starts, so the initial auto-connect respects the persisted setting.
+pub fn set_mtp_enabled_flag(enabled: bool) {
+    MTP_ENABLED.store(enabled, Ordering::SeqCst);
+    debug!("MTP enabled flag set to {}", enabled);
+}
+
+/// Enables or disables MTP support at runtime.
+///
+/// When disabling: disconnects all connected devices, clears known devices,
+/// and restores ptpcamerad (macOS). When enabling: re-checks for plugged-in
+/// devices so they get auto-connected.
+pub async fn set_mtp_enabled(enabled: bool) {
+    let was_enabled = MTP_ENABLED.swap(enabled, Ordering::SeqCst);
+    if was_enabled == enabled {
+        debug!("MTP enabled unchanged ({})", enabled);
+        return;
+    }
+
+    info!("MTP support {}", if enabled { "enabled" } else { "disabled" });
+
+    if enabled {
+        check_for_device_changes();
+    } else {
+        // Disconnect all connected devices
+        let cm = super::connection_manager();
+        let connected = cm.get_all_connected_devices().await;
+        for device in &connected {
+            let device_id = device.device.id.clone();
+            auto_disconnect_device(device_id);
+        }
+
+        // Clear known devices so re-enable detects everything as new
+        if let Some(known) = KNOWN_DEVICES.get()
+            && let Ok(mut guard) = known.lock()
+        {
+            guard.clear();
+        }
+
+        // Restore ptpcamerad on macOS
+        #[cfg(target_os = "macos")]
+        restore_ptpcamerad_unconditionally();
+    }
+}
+
 /// Gets the current set of MTP devices using mtp-rs discovery.
 fn get_current_mtp_devices() -> HashSet<String> {
     let devices = super::list_mtp_devices();
@@ -28,7 +78,12 @@ fn get_current_mtp_devices() -> HashSet<String> {
 
 /// Checks for MTP device changes by comparing current state with known state.
 /// Auto-connects newly detected devices and disconnects removed ones.
+/// Returns early if MTP is disabled.
 fn check_for_device_changes() {
+    if !MTP_ENABLED.load(Ordering::SeqCst) {
+        return;
+    }
+
     let current_devices = get_current_mtp_devices();
 
     let known = match KNOWN_DEVICES.get() {
@@ -133,8 +188,8 @@ pub fn start_mtp_watcher(app: &AppHandle) {
         initial_devices.len()
     );
 
-    // Auto-connect any devices already plugged in at startup
-    if !initial_devices.is_empty() {
+    // Auto-connect any devices already plugged in at startup (skip if MTP is disabled)
+    if !initial_devices.is_empty() && MTP_ENABLED.load(Ordering::SeqCst) {
         #[cfg(target_os = "macos")]
         suppress_ptpcamerad_if_needed();
 
@@ -214,6 +269,24 @@ fn suppress_ptpcamerad_if_needed() {
     }
 }
 
+/// Restores ptpcamerad unconditionally (used when MTP is disabled).
+/// Emits `mtp-ptpcamerad-restored` event on success.
+#[cfg(target_os = "macos")]
+fn restore_ptpcamerad_unconditionally() {
+    use tauri::Emitter;
+
+    match super::macos_workaround::restore_ptpcamerad() {
+        Ok(true) => {
+            info!("Restored ptpcamerad (MTP disabled)");
+            if let Some(app) = APP_HANDLE.get() {
+                let _ = app.emit("mtp-ptpcamerad-restored", ());
+            }
+        }
+        Ok(false) => {} // Wasn't suppressed
+        Err(e) => warn!("Failed to restore ptpcamerad: {}", e),
+    }
+}
+
 /// Restores ptpcamerad when no MTP devices remain connected.
 /// Emits `mtp-ptpcamerad-restored` event on success.
 #[cfg(target_os = "macos")]
@@ -243,9 +316,28 @@ mod tests {
 
     #[test]
     fn test_get_current_mtp_devices() {
-        // This test just verifies the function runs without panicking
+        // This test verifies the function runs without panicking
         let devices = get_current_mtp_devices();
         // The function should complete without error (even if empty)
         assert!(devices.is_empty() || !devices.is_empty());
     }
+
+    #[test]
+    fn test_mtp_enabled_flag_defaults_to_true() {
+        assert!(MTP_ENABLED.load(Ordering::SeqCst));
+    }
+
+    #[test]
+    fn test_set_mtp_enabled_flag() {
+        let original = MTP_ENABLED.load(Ordering::SeqCst);
+
+        set_mtp_enabled_flag(false);
+        assert!(!MTP_ENABLED.load(Ordering::SeqCst));
+
+        set_mtp_enabled_flag(true);
+        assert!(MTP_ENABLED.load(Ordering::SeqCst));
+
+        // Restore original state
+        MTP_ENABLED.store(original, Ordering::SeqCst);
+    }
 }

apps/desktop/src-tauri/src/settings/CLAUDE.md

@@ -21,6 +21,8 @@ Settings {
     crash_reports_enabled: Option<bool>,  // from "updates.crashReports"
     ai_provider: Option<String>,           // from "ai.provider", for crash reports
     verbose_logging: Option<bool>,         // from "developer.verboseLogging", for crash reports
+    direct_smb_connection: Option<bool>,   // from "network.directSmbConnection"
+    mtp_enabled: Option<bool>,             // from "fileOperations.mtpEnabled"
 }
 ```
 

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

@@ -51,6 +51,8 @@ pub struct Settings {
     pub verbose_logging: Option<bool>,
     #[serde(alias = "network.directSmbConnection", default)]
     pub direct_smb_connection: Option<bool>,
+    #[serde(alias = "fileOperations.mtpEnabled", default)]
+    pub mtp_enabled: Option<bool>,
 }
 
 fn default_show_hidden() -> bool {
@@ -69,6 +71,7 @@ impl Default for Settings {
             ai_provider: None,
             verbose_logging: None,
             direct_smb_connection: None,
+            mtp_enabled: None,
         }
     }
 }
@@ -116,6 +119,7 @@ fn parse_settings(contents: &str) -> Result<Settings, serde_json::Error> {
     let ai_provider = json.get("ai.provider").and_then(|v| v.as_str()).map(String::from);
     let verbose_logging = json.get("developer.verboseLogging").and_then(|v| v.as_bool());
     let direct_smb_connection = json.get("network.directSmbConnection").and_then(|v| v.as_bool());
+    let mtp_enabled = json.get("fileOperations.mtpEnabled").and_then(|v| v.as_bool());
 
     Ok(Settings {
         show_hidden_files,
@@ -127,5 +131,6 @@ fn parse_settings(contents: &str) -> Result<Settings, serde_json::Error> {
         ai_provider,
         verbose_logging,
         direct_smb_connection,
+        mtp_enabled,
     })
 }

apps/desktop/src-tauri/src/stubs/mtp.rs

@@ -59,6 +59,10 @@ impl std::fmt::Display for MtpConnectionError {
 
 impl std::error::Error for MtpConnectionError {}
 
+/// Enables or disables MTP support (stub - no-op).
+#[tauri::command]
+pub async fn set_mtp_enabled(_enabled: bool) {}
+
 /// Lists connected MTP devices (stub - always returns empty).
 #[tauri::command]
 pub fn list_mtp_devices() -> Vec<MtpDeviceInfo> {

apps/desktop/src/lib/file-explorer/navigation/CLAUDE.md

@@ -125,13 +125,14 @@ keyboard navigation (ArrowRight to open, ArrowLeft/Escape to close, Enter to act
 These patterns emerged during the volume picker implementation and should be followed in future dropdown/submenu work:
 
 - **CSS triangles for arrows/chevrons**, not font characters. Font-based arrows (`▾`, `›`) render at inconsistent sizes
-  across fonts and OS versions. Use the CSS border trick (`border-left: 4px solid transparent; border-right: 4px solid
-  transparent; border-top: 5px solid currentcolor`) for pixel-perfect control.
+  across fonts and OS versions. Use the CSS border trick
+  (`border-left: 4px solid transparent; border-right: 4px solid transparent; border-top: 5px solid currentcolor`) for
+  pixel-perfect control.
 - **Single cursor rule.** When a submenu opens, suppress the main menu highlight. Exactly one cursor should be visible
   at all times. Use a state flag (like `submenuVolumeId`) to conditionally remove the `is-focused-and-under-cursor`
   class from the main menu.
-- **Elements with independent actions must be outside their parent's click area.** If a button inside another button
-  has a different action (like "Volume options" inside "Volume selector"), it must be a sibling, not a child. Otherwise
+- **Elements with independent actions must be outside their parent's click area.** If a button inside another button has
+  a different action (like "Volume options" inside "Volume selector"), it must be a sibling, not a child. Otherwise
   `stopPropagation` fights with the parent's click handler.
 - **Fixed positioning for submenus inside scrollable containers.** A submenu inside a `overflow-y: auto` dropdown gets
   clipped. Use `position: fixed` with coordinates calculated from `getBoundingClientRect()` of the trigger element.

apps/desktop/src/lib/mtp/CLAUDE.md

@@ -24,6 +24,12 @@ Multiple storages (Internal + SD Card) become separate volumes in UI. Each has d
 Listen to `mtp-directory-changed` events from backend. When device emits MTP `ObjectAdded/Removed/Changed`, backend
 sends event with `deviceId`. Frontend re-fetches current directory if viewing that device.
 
+### Settings toggle (`fileOperations.mtpEnabled`)
+
+MTP support can be disabled entirely from Settings > General > File operations. The toggle calls `setMtpEnabled()`
+(wired through `settings-applier.ts`), which invokes the `set_mtp_enabled` Tauri command. When disabled, all devices
+disconnect and hotplug events are ignored. The frontend is passive — it reacts to `volumes-changed` events as usual.
+
 ### Automatic ptpcamerad suppression (macOS)
 
 On macOS, `ptpcamerad` daemon auto-claims MTP/PTP devices. The backend now handles this automatically: