v0.1.8: Add Eject button and improved disk detection

- Add Eject button to safely power down disks via diskutil eject
- Add polling fallback (every 3s) to detect Linux-only disk changes
- Recognize "Linux Filesystem" partition type as supported
- Merge native and MS fallback disk detection results

Author: fenio

CHANGELOG.md

@@ -2,13 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.1.7] - 2025-01-27
+## [0.1.8] - 2025-01-27
+
+### Added
+- Eject button to safely power down and remove disks
 
 ### Fixed
 - Disk detection now merges native and MS fallback results
 - Linux-only cards now properly detected (not filtered by -m flag)
 - Cards with broken GUID tables still work via MS fallback
 - "Linux Filesystem" partition type now recognized as supported
+- Disk watcher now polls for physical disk changes (catches Linux-only disks)
 
 ## [0.1.6] - 2025-01-27
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "anylinuxfs-gui",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "private": true,
   "type": "module",
   "scripts": {

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "anylinuxfs-gui"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 
 [lib]

src-tauri/Cargo.toml

@@ -551,6 +551,27 @@ pub async fn unmount_disk() -> Result<String, String> {
     .map_err(|e| format!("Task error: {}", e))?
 }
 
+#[tauri::command]
+pub async fn eject_disk(device: String) -> Result<String, String> {
+    // Eject (power down) a disk using diskutil
+    // This is useful for Linux-only disks that aren't auto-ejected
+    tokio::task::spawn_blocking(move || {
+        let output = Command::new("diskutil")
+            .args(["eject", &device])
+            .output()
+            .map_err(|e| format!("Failed to run diskutil: {}", e))?;
+
+        if output.status.success() {
+            Ok(format!("Ejected {}", device))
+        } else {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            Err(format!("Failed to eject: {}", stderr))
+        }
+    })
+    .await
+    .map_err(|e| format!("Task error: {}", e))?
+}
+
 #[tauri::command]
 pub async fn force_cleanup() -> Result<String, String> {
     // Force kill orphaned anylinuxfs/krun processes

src-tauri/src/commands/disk.rs

@@ -206,10 +206,23 @@ pub fn start_disk_watcher(app: AppHandle) -> Result<(), String> {
             return;
         }
 
+        // Also watch /dev for physical disk connect/disconnect events
+        // This catches Linux-only disks that don't get mounted to /Volumes
+        let dev_path = PathBuf::from("/dev");
+        if watcher.watch(&dev_path, RecursiveMode::NonRecursive).is_err() {
+            eprintln!("Failed to watch /dev (continuing with /Volumes only)");
+            // Don't return - /Volumes watching is still useful
+        }
+
         // Track pending event - we wait for events to settle before emitting
         let mut pending_event: Option<Instant> = None;
         let settle_duration = Duration::from_millis(1500); // Wait 1.5s after last event
 
+        // Track disk count for polling fallback (for Linux-only disks not in /Volumes)
+        let mut last_disk_count = count_disks();
+        let mut last_poll = Instant::now();
+        let poll_interval = Duration::from_secs(3); // Poll every 3 seconds
+
         loop {
             // Check if we should stop
             if state_clone.disk_watcher_stop.load(Ordering::SeqCst) {
@@ -220,8 +233,18 @@ pub fn start_disk_watcher(app: AppHandle) -> Result<(), String> {
                 Ok(Ok(event)) => {
                     match event.kind {
                         EventKind::Create(_) | EventKind::Remove(_) => {
-                            // Mark that we have a pending event, reset settle timer
-                            pending_event = Some(Instant::now());
+                            // Filter /dev events to only disk-related changes
+                            let is_disk_event = event.paths.iter().any(|p| {
+                                let path_str = p.to_string_lossy();
+                                // Match /Volumes/* or /dev/disk*
+                                path_str.starts_with("/Volumes/") ||
+                                (path_str.starts_with("/dev/disk") && !path_str.contains("s"))
+                            });
+
+                            if is_disk_event {
+                                // Mark that we have a pending event, reset settle timer
+                                pending_event = Some(Instant::now());
+                            }
                         }
                         _ => {}
                     }
@@ -236,8 +259,20 @@ pub fn start_disk_watcher(app: AppHandle) -> Result<(), String> {
                             // Events have settled, emit and clear
                             let _ = app.emit("disks-changed", ());
                             pending_event = None;
+                            last_disk_count = count_disks(); // Update count after emit
                         }
                     }
+
+                    // Polling fallback: check disk count periodically
+                    // This catches Linux-only disks that don't trigger /Volumes events
+                    if last_poll.elapsed() >= poll_interval {
+                        let current_count = count_disks();
+                        if current_count != last_disk_count {
+                            pending_event = Some(Instant::now());
+                            last_disk_count = current_count;
+                        }
+                        last_poll = Instant::now();
+                    }
                 }
             }
         }
@@ -248,6 +283,24 @@ pub fn start_disk_watcher(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
+/// Count physical disks by checking /dev/disk* entries
+fn count_disks() -> usize {
+    std::fs::read_dir("/dev")
+        .map(|entries| {
+            entries
+                .filter_map(|e| e.ok())
+                .filter(|e| {
+                    let name = e.file_name();
+                    let name_str = name.to_string_lossy();
+                    // Match disk0, disk1, etc. but not disk0s1 (partitions)
+                    name_str.starts_with("disk") &&
+                    name_str[4..].chars().all(|c| c.is_ascii_digit())
+                })
+                .count()
+        })
+        .unwrap_or(0)
+}
+
 #[tauri::command]
 pub fn stop_watchers(app: AppHandle) -> Result<(), String> {
     let state = app.state::<Arc<WatcherState>>();

src-tauri/src/commands/log.rs

@@ -3,7 +3,7 @@ mod commands;
 
 use std::sync::{Arc, Mutex};
 use commands::{
-    list_disks, mount_disk, unmount_disk, force_cleanup,
+    list_disks, mount_disk, unmount_disk, eject_disk, force_cleanup,
     get_mount_status, check_cli,
     get_log_content, start_log_stream, start_disk_watcher, stop_watchers,
     get_config, update_config,
@@ -23,6 +23,7 @@ pub fn run() {
             list_disks,
             mount_disk,
             unmount_disk,
+            eject_disk,
             force_cleanup,
             get_mount_status,
             check_cli,

src-tauri/src/lib.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "anylinuxfs-gui",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "identifier": "com.anylinuxfs.gui",
   "build": {
     "beforeDevCommand": "npm run dev",

src-tauri/tauri.conf.json

@@ -5,7 +5,9 @@
 	import PassphraseDialog from './PassphraseDialog.svelte';
 	import { onMount } from 'svelte';
 	import { listen } from '@tauri-apps/api/event';
-	import { startDiskWatcher } from '$lib/api';
+	import { startDiskWatcher, ejectDisk } from '$lib/api';
+
+	let ejectingDevice: string | null = $state(null);
 
 	let passphraseDevice: string | null = $state(null);
 
@@ -59,6 +61,19 @@
 		disks.setAdminMode(checked);
 		disks.refresh(checked);
 	}
+
+	async function handleEject(device: string) {
+		ejectingDevice = device;
+		try {
+			await ejectDisk(device);
+			// Refresh after successful eject
+			disks.refresh();
+		} catch (e) {
+			console.error('Failed to eject:', e);
+		} finally {
+			ejectingDevice = null;
+		}
+	}
 </script>
 
 <div class="disk-list">
@@ -120,6 +135,18 @@
 						<span class="disk-model">{disk.model}</span>
 					{/if}
 					<span class="disk-size">{disk.size}</span>
+					<button
+						class="eject-btn"
+						onclick={() => handleEject(disk.device)}
+						disabled={ejectingDevice === disk.device}
+						title="Eject disk (safely remove)"
+					>
+						{#if ejectingDevice === disk.device}
+							<span class="spinner small"></span>
+						{:else}
+							⏏
+						{/if}
+					</button>
 				</div>
 				<div class="partitions">
 					{#each disk.partitions as partition}
@@ -332,6 +359,37 @@
 		margin-left: auto;
 	}
 
+	.eject-btn {
+		padding: 4px 8px;
+		border-radius: 4px;
+		border: 1px solid var(--border-color);
+		background: var(--button-secondary-bg);
+		color: var(--text-secondary);
+		font-size: 14px;
+		cursor: pointer;
+		transition: all 0.15s;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		min-width: 32px;
+	}
+
+	.eject-btn:hover:not(:disabled) {
+		background: var(--button-secondary-hover);
+		color: var(--text-primary);
+	}
+
+	.eject-btn:disabled {
+		opacity: 0.6;
+		cursor: not-allowed;
+	}
+
+	.spinner.small {
+		width: 12px;
+		height: 12px;
+		border-width: 2px;
+	}
+
 	.partitions {
 		display: flex;
 		flex-direction: column;

src/components/DiskList.svelte

@@ -17,6 +17,10 @@ export async function unmountDisk(): Promise<string> {
 	return await invoke<string>('unmount_disk');
 }
 
+export async function ejectDisk(device: string): Promise<string> {
+	return await invoke<string>('eject_disk', { device });
+}
+
 export async function forceCleanup(): Promise<string> {
 	return await invoke<string>('force_cleanup');
 }