Context menu: Open with, cloud actions, Services menu

- "Open with" submenu in the file context menu, populated via `NSWorkspace.URLsForApplicationsToOpenURL:`. Multi-selection intersects per-file candidates and launches all paths in one `openURLs:withApplicationAtURL:configuration:` call. App-bundle icons rendered via `IconMenuItem` (full-color, not template). Default app marked with " (default)" plain-text suffix; will dim once `tauri-apps/muda#353` lands and Tauri exposes the typed setter.
- Session-scoped candidate cache keyed by lowercased extension, invalidated on `NSWorkspace.didLaunchApplicationNotification` / `didTerminateApplicationNotification`.
- "Open with → Other..." opens a native `NSOpenPanel` filtered to `.app` bundles.
- Worker threads use 8 MB stacks (FileProvider XPC stack-depth pattern from `sync_status.rs`).
- Cloud actions ("Make available offline" / "Remove download") gated on cloud-storage paths and current sync status. Wraps `NSFileProviderManager.evictItem` / `requestDownloadForItem` async APIs through completion handler + `mpsc::sync_channel`. Diagnostic logging via `log::warn!` with `target: "cloud_actions"` captures NSError code/domain on failure.
- File context menu's "Copy 'filename'" item truncates with middle ellipsis at 50 chars (preserves extension) so long filenames don't blow up the menu width.
- System Services menu in the cmdr app menu via `PredefinedMenuItem::services` — populated by AppKit with services registered by other apps.
- Open-with click events are prefix-routed (`open-with:<bundle-id>`) before the unified `menu_id_to_command` lookup, since per-app IDs are too dynamic to enumerate. Bundle-id → app-path map cached on `MenuState.context.open_with_apps` per right-click.
- Frontend command registry adds `cloud.makeOffline` / `cloud.removeDownload` (macOS-only in palette); `command-dispatch` routes them to the new Tauri commands.
- File context menu now passes the full multi-selection paths so cloud + open-with actions apply to the whole selection (Finder convention: action follows selection if right-clicked entry is part of it).

Author: vdavid

Cargo.lock

@@ -150,11 +150,15 @@ urlencoding = "2.1.3"
 objc2 = { version = "0.6", features = ["std", "exception"] }
 objc2-foundation = { version = "0.3", features = [
     "NSURL", "NSString", "NSDictionary", "NSDate", "NSArray", "NSValue", "NSError",
-    "NSFileManager", "NSNotification",
+    "NSFileManager", "NSNotification", "NSBundle",
 ] }
 objc2-app-kit = { version = "0.3", features = [
     "NSDragging", "NSDraggingItem", "NSImage", "NSColor", "NSColorSpace",
     "NSApplication", "NSMenu", "NSMenuItem", "NSPasteboard", "NSRunningApplication",
+    "NSWorkspace", "NSPanel", "NSOpenPanel", "NSSavePanel", "NSWindow", "NSResponder",
+] }
+objc2-file-provider = { version = "0.3", features = [
+    "Extension", "NSFileProviderDomain", "NSFileProviderItem", "NSFileProviderError",
 ] }
 block2 = "0.6"
 security-framework = "3.2"

apps/desktop/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 use crate::ignore_poison::IgnorePoison;
 use crate::menu::{
-    CLOSE_TAB_ID, CommandScope, MenuState, build_breadcrumb_context_menu, build_context_menu,
+    CLOSE_TAB_ID, CommandScope, FileContextInfo, MenuState, build_breadcrumb_context_menu, build_context_menu,
     build_network_host_context_menu, build_tab_context_menu, frontend_shortcut_to_accelerator, menu_id_to_command,
 };
 #[cfg(any(target_os = "macos", target_os = "linux"))]
@@ -23,18 +23,82 @@ pub fn show_file_context_menu<R: Runtime>(
     path: String,
     filename: String,
     is_directory: bool,
+    paths: Vec<String>,
 ) -> Result<(), String> {
     let app = window.app_handle();
 
-    // Update context first so menu events have the right data
-    update_menu_context(app.clone(), path, filename.clone());
+    // The "primary" path drives single-file actions like "Copy 'filename'", Get info,
+    // Quick look. `paths` carries the full selection that "Open with" and cloud actions
+    // should apply to — it equals `[path]` when the right-clicked file isn't part of a
+    // multi-selection, or the entire selection otherwise.
+    let context_paths = if paths.is_empty() { vec![path.clone()] } else { paths };
+
+    // Compute per-file context (sync status, FP-domain membership, candidate "Open with"
+    // apps). The LaunchServices query for candidates can take 50-200 ms on a cold cache,
+    // which delays the popup; the cache (in `file_system::open_with`) keeps later
+    // right-clicks fast.
+    #[cfg(target_os = "macos")]
+    let info = build_file_context_info(&path, &context_paths);
+    #[cfg(not(target_os = "macos"))]
+    let info = FileContextInfo;
+
+    // Update menu context so on_menu_event has paths + bundle map for the new items.
+    {
+        let state = app.state::<MenuState<R>>();
+        let mut context = state.context.lock_ignore_poison();
+        context.path = path.clone();
+        context.filename = filename.clone();
+        context.paths = context_paths;
+        #[cfg(target_os = "macos")]
+        {
+            // Filled in from build_context_menu's return value below.
+            context.open_with_apps.clear();
+        }
+    }
 
-    let menu = build_context_menu(app, &filename, is_directory).map_err(|e| e.to_string())?;
-    menu.popup(window).map_err(|e| e.to_string())?;
+    let result = build_context_menu(app, &filename, is_directory, &info).map_err(|e| e.to_string())?;
+
+    // Stash the bundle_id → app_path map so on_menu_event can resolve clicks on
+    // `open-with:<bundle-id>` items back to a real app URL.
+    #[cfg(target_os = "macos")]
+    {
+        let state = app.state::<MenuState<R>>();
+        let mut context = state.context.lock_ignore_poison();
+        context.open_with_apps = result.open_with_apps;
+    }
+
+    result.menu.popup(window).map_err(|e| e.to_string())?;
 
     Ok(())
 }
 
+#[cfg(target_os = "macos")]
+fn build_file_context_info(primary_path: &str, all_paths: &[String]) -> FileContextInfo {
+    use crate::file_system::cloud_actions::is_in_cloud_storage;
+    use crate::file_system::open_with::compute_open_with_choices;
+    use crate::file_system::sync_status::get_sync_statuses;
+    use std::path::PathBuf;
+
+    let path_buf = PathBuf::from(primary_path);
+    let is_cloud = is_in_cloud_storage(&path_buf);
+
+    // Sync status of the primary path only — drives the cloud-action label.
+    let sync_status = if is_cloud {
+        let mut statuses = get_sync_statuses(vec![primary_path.to_string()]);
+        statuses.remove(primary_path).unwrap_or_default()
+    } else {
+        Default::default()
+    };
+
+    let open_with = compute_open_with_choices(all_paths.iter().map(PathBuf::from).collect());
+
+    FileContextInfo {
+        sync_status,
+        is_cloud,
+        open_with,
+    }
+}
+
 /// Shows a native context menu for the breadcrumb path bar.
 /// The `shortcut` is the user's configured shortcut in frontend format (e.g. "⌃⌘C"),
 /// or empty string if no shortcut is configured.
@@ -209,6 +273,27 @@ pub fn open_in_editor(path: String) -> Result<(), String> {
     Ok(())
 }
 
+/// Make a cloud-managed file available offline (download it). On macOS, talks to the
+/// File Provider extension responsible for the file (iCloud Drive, Dropbox, GDrive,
+/// OneDrive, Box, etc.).
+#[tauri::command]
+pub async fn cloud_make_available_offline(path: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        crate::file_system::cloud_actions::request_download(std::path::Path::new(&path))
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+/// Evict a cloud-managed file's local copy, leaving a placeholder. Counterpart to
+/// `cloud_make_available_offline`.
+#[tauri::command]
+pub async fn cloud_remove_download(path: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || crate::file_system::cloud_actions::evict_item(std::path::Path::new(&path)))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
 #[tauri::command]
 #[cfg(target_os = "linux")]
 pub fn open_in_editor(path: String) -> Result<(), String> {

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

@@ -4,6 +4,22 @@ Core filesystem operations: directory listing, file writing, sync status, volume
 
 Submodule docs: [listing/](listing/CLAUDE.md), [write_operations/](write_operations/CLAUDE.md), [volume/](volume/CLAUDE.md).
 
+## Cloud actions and "Open with" (macOS)
+
+- `cloud_actions.rs` — wraps `NSFileProviderManager.evictItem(...)` and
+  `requestDownloadForItem(...)` so the file context menu can offer "Make available offline" and
+  "Remove download" for any File-Provider-managed file (iCloud Drive, Dropbox, Google Drive,
+  OneDrive, Box). Detection is fast (`is_in_cloud_storage` — pure path-prefix check against
+  `~/Library/Mobile Documents/com~apple~CloudDocs` and `~/Library/CloudStorage/`); the actual
+  evict/download chain calls async FP APIs synchronously via completion handlers + `mpsc::sync_channel`.
+- `open_with.rs` — `URLsForApplicationsToOpenURL:` for candidate apps, with multi-selection
+  intersection. Session cache keyed by lowercased extension. Subscribes to
+  `NSWorkspace.didLaunchApplicationNotification` / `didTerminateApplicationNotification` for
+  invalidation (per AGENTS.md "Subscribe, don't poll" — TTL is fallback only). `open_paths_with`
+  launches with one multi-URL `openURLs:withApplicationAtURL:configuration:completionHandler:`
+  call. `pick_app_via_open_panel` shows `NSOpenPanel` filtered to `.app` bundles for the
+  "Open with → Other..." entry. Worker threads use 8 MB stacks (FileProvider XPC depth).
+
 ## Gotchas
 
 **Never use rayon (or any constrained-stack thread pool) for calls into macOS frameworks.**