Bugfix: Google Drive panes refresh live after rename, create, and delete

Renaming (or creating/deleting) a file in a Google Drive "My Drive" pane
left the pane showing the old listing until the user navigated away and
back. Local drives, SMB, iCloud, and Dropbox all refreshed fine.

Root cause: Google Drive for desktop exposes "My Drive" as a **symlink**
(`…/CloudStorage/GoogleDrive-…/My Drive` → `~/My Drive`), whereas iCloud
and Dropbox mount real directories. The pane's FSEvents watcher is rooted
at the symlinked listing dir, and FSEvents resolves the symlink and reports
events under the real target (`~/My Drive/…`). `rebase_event_path` only
firmlink-normalized the paths (`/tmp` → `/private/tmp`, …), so the
real-target event path never matched the symlink-form listing path and every
event was dropped — no `directory-diff`, no refresh. The indexing watcher was
unaffected (it's volume-root-rooted and matches by inode), which is why the
change still showed up after a re-navigate.

Fix: `handle_directory_change_incremental` now `canonicalize`s the watched
dir once per debounce batch and `rebase_event_path` matches the event's parent
against that symlink-resolved form too, still rebasing onto the listing's own
path space so cache lookups and diff indices stay consistent. The canonicalize
is one `realpath` per batch, the same syscall class as the per-event stats
already there.

Verified: FSEvents probe confirmed a symlink-rooted stream reports events under
the real target; `realpath` on the live Drive path yields `~/My Drive`, matching
what FSEvents reports. Red/green unit test `test_rebase_event_path_resolves_symlinked_watch_root`.

Author: vdavid

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

@@ -29,7 +29,10 @@ via `set_tags` / `toggle_color` behind the `toggle_tags` command).
   FSEvents reports canonical paths (`/private/tmp/…`) while `LISTING_CACHE` holds the user-navigated form (`/tmp/…`).
   The incremental handler compares the firmlink-normalized forms (`indexing::firmlinks::normalize_path`) and rebases
   matching event paths onto the listing's directory. A raw `path.parent() == dir_path` comparison silently dropped every
-  event for listings under `/tmp`, `/var`, and `/etc`, so the pane never updated until the user re-navigated.
+  event for listings under `/tmp`, `/var`, and `/etc`, so the pane never updated until the user re-navigated. FSEvents
+  also resolves a **symlinked watch root** and reports events under the real target, so the handler also matches against
+  the `canonicalize`d watch dir. This bit Google Drive, whose `My Drive` is a symlink to `~/My Drive`, so rename/create/
+  delete never refreshed the pane; iCloud and Dropbox mount real directories and hit the firmlink path instead.
 - **`cloud_actions.rs` is iCloud Drive only.** The `NSFileProviderManager` host-side methods look cross-provider but are
   reserved for the app that *bundles* the File Provider extension, so third-party apps get
   `NSFileProviderErrorProviderNotFound`. The `FileManager` ubiquity APIs route through iCloud's path and accept any URL

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

@@ -176,22 +176,31 @@ pub fn stop_watching(listing_id: &str) {
 /// Maps an FSEvents/inotify path to the watched listing's path space, returning the
 /// rebased path when the event is for a direct child of the watched directory.
 ///
-/// On macOS, FSEvents reports canonical paths (`/private/tmp/…`) while the listing
-/// cache holds the user-navigated form (`/tmp/…`). A raw parent comparison silently
-/// drops every event for listings under `/tmp`, `/var`, or `/etc` — the pane then
-/// never updates until the user re-navigates. The comparison runs on the
-/// symlink/firmlink-normalized forms (`firmlinks::normalize_path`, the same
-/// canonicalization the index uses), and the returned path is rebased onto
-/// `dir_path` so cache lookups (`has_entry`) and diff entries stay consistent with
-/// the listing's own paths.
-pub(super) fn rebase_event_path(event_path: &Path, dir_path: &Path) -> Option<PathBuf> {
+/// Two path-form mismatches make a raw `parent == dir_path` comparison silently drop
+/// events, leaving the pane stale until the user re-navigates:
+///
+/// 1. **Firmlinks / well-known `/private` symlinks.** FSEvents reports canonical paths
+///    (`/private/tmp/…`) while the listing cache holds the user-navigated form
+///    (`/tmp/…`). `firmlinks::normalize_path` (the same canonicalization the index
+///    uses) aligns both.
+/// 2. **A symlinked watch root.** Google Drive exposes "My Drive" as a symlink
+///    (`…/CloudStorage/GoogleDrive-…/My Drive` → `~/My Drive`), and FSEvents resolves
+///    the watched symlink and reports events under the real target. `canonical_dir` is
+///    `dir_path` with its symlinks resolved (see the caller); matching against it
+///    catches this case. iCloud and Dropbox mount real directories, so they hit the
+///    firmlink path above; only Google Drive needs this branch.
+///
+/// The returned path is always rebased onto `dir_path` so cache lookups (`has_entry`)
+/// and diff entries stay consistent with the listing's own path space.
+pub(super) fn rebase_event_path(event_path: &Path, dir_path: &Path, canonical_dir: &Path) -> Option<PathBuf> {
     let parent = event_path.parent()?;
     if parent == dir_path {
         return Some(event_path.to_path_buf());
     }
     let parent_normalized = crate::indexing::firmlinks::normalize_path(&parent.to_string_lossy());
     let dir_normalized = crate::indexing::firmlinks::normalize_path(&dir_path.to_string_lossy());
-    if parent_normalized == dir_normalized {
+    let canonical_normalized = crate::indexing::firmlinks::normalize_path(&canonical_dir.to_string_lossy());
+    if parent_normalized == dir_normalized || parent_normalized == canonical_normalized {
         event_path.file_name().map(|name| dir_path.join(name))
     } else {
         None
@@ -221,6 +230,13 @@ fn handle_directory_change_incremental(listing_id: &str, events: Vec<DebouncedEv
         return;
     };
 
+    // Resolve the watched dir's symlinks once per batch, so events FSEvents reports
+    // under a symlinked root's real target (Google Drive's "My Drive" → `~/My Drive`)
+    // still match. This is a `realpath` syscall like the per-event `get_single_entry`
+    // stats below, so it adds no new blocking class here; falls back to `dir_path` if
+    // the dir vanished mid-batch (the re-read path handles a deleted watch root).
+    let canonical_dir = std::fs::canonicalize(&dir_path).unwrap_or_else(|_| dir_path.clone());
+
     // Collect unique direct-child paths, skipping access events. Event paths are
     // rebased into the listing's path space (see `rebase_event_path`).
     let mut unique_paths: HashSet<PathBuf> = HashSet::new();
@@ -229,7 +245,7 @@ fn handle_directory_change_incremental(listing_id: &str, events: Vec<DebouncedEv
             continue;
         }
         for path in &event.paths {
-            if let Some(rebased) = rebase_event_path(path, &dir_path) {
+            if let Some(rebased) = rebase_event_path(path, &dir_path, &canonical_dir) {
                 unique_paths.insert(rebased);
             }
         }

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

@@ -31,8 +31,9 @@ fn make_entry_in(name: &str, dir: &str, size: Option<u64>) -> FileEntry {
 
 #[test]
 fn test_rebase_event_path_exact_parent_match() {
+    let dir = Path::new("/Users/jane/docs");
     assert_eq!(
-        rebase_event_path(Path::new("/Users/jane/docs/file.txt"), Path::new("/Users/jane/docs")),
+        rebase_event_path(Path::new("/Users/jane/docs/file.txt"), dir, dir),
         Some(PathBuf::from("/Users/jane/docs/file.txt"))
     );
 }
@@ -42,32 +43,69 @@ fn test_rebase_event_path_exact_parent_match() {
 fn test_rebase_event_path_resolves_private_symlink() {
     // Pre-fix, FSEvents' canonical /private/tmp/... paths never matched a listing
     // watched as /tmp/..., so the pane silently never updated.
+    let dir = Path::new("/tmp/work");
     assert_eq!(
-        rebase_event_path(Path::new("/private/tmp/work/new-dir"), Path::new("/tmp/work")),
+        rebase_event_path(Path::new("/private/tmp/work/new-dir"), dir, dir),
         Some(PathBuf::from("/tmp/work/new-dir")),
         "canonical event path must rebase into the listing's /tmp path space"
     );
     // And the inverse orientation (listing opened via the canonical path)
+    let dir = Path::new("/private/tmp/work");
     assert_eq!(
-        rebase_event_path(Path::new("/tmp/work/new-dir"), Path::new("/private/tmp/work")),
+        rebase_event_path(Path::new("/tmp/work/new-dir"), dir, dir),
         Some(PathBuf::from("/private/tmp/work/new-dir"))
     );
 }
 
+#[test]
+fn test_rebase_event_path_resolves_symlinked_watch_root() {
+    // Google Drive exposes "My Drive" as a symlink (…/CloudStorage/GoogleDrive-…/My Drive
+    // → ~/My Drive). FSEvents resolves the watched symlink and reports events under the
+    // real target, which never matched the listing's symlink-form path, so the pane
+    // silently never updated on rename/create/delete. `canonical_dir` (the symlink-
+    // resolved watch root) closes the gap; the rebase still lands in the listing's own
+    // path space.
+    let listing_dir = Path::new("/Users/jane/Library/CloudStorage/GoogleDrive-jane/My Drive");
+    let canonical_dir = Path::new("/Users/jane/My Drive");
+    assert_eq!(
+        rebase_event_path(Path::new("/Users/jane/My Drive/photo.jpg"), listing_dir, canonical_dir),
+        Some(PathBuf::from(
+            "/Users/jane/Library/CloudStorage/GoogleDrive-jane/My Drive/photo.jpg"
+        )),
+        "event under the symlink-resolved target must rebase into the listing's own path space"
+    );
+    // A sibling of the real target, outside the watched dir, stays rejected.
+    assert_eq!(
+        rebase_event_path(Path::new("/Users/jane/Other/photo.jpg"), listing_dir, canonical_dir),
+        None
+    );
+}
+
 #[test]
 fn test_rebase_event_path_rejects_non_children() {
     // Different directory
     assert_eq!(
-        rebase_event_path(Path::new("/private/tmp/other/file"), Path::new("/tmp/work")),
+        rebase_event_path(
+            Path::new("/private/tmp/other/file"),
+            Path::new("/tmp/work"),
+            Path::new("/tmp/work")
+        ),
         None
     );
     // Deeper descendant (watcher is non-recursive; only direct children count)
     assert_eq!(
-        rebase_event_path(Path::new("/private/tmp/work/sub/file"), Path::new("/tmp/work")),
+        rebase_event_path(
+            Path::new("/private/tmp/work/sub/file"),
+            Path::new("/tmp/work"),
+            Path::new("/tmp/work")
+        ),
         None
     );
     // Prefix-similar but distinct dir name must not match (/tmpdir is not /tmp)
-    assert_eq!(rebase_event_path(Path::new("/tmpdir/file"), Path::new("/tmp")), None);
+    assert_eq!(
+        rebase_event_path(Path::new("/tmpdir/file"), Path::new("/tmp"), Path::new("/tmp")),
+        None
+    );
 }
 
 #[test]