@photostructure/fs-metadata 1.2.0 → 1.4.0

package/src/volume_metadata.ts

@@ -95,7 +95,8 @@ async function _getVolumeMetadata(
       }
     } catch (err) {
       debug("[getVolumeMetadata] failed to get mtab info: " + err);
-      // this may be a GIO mount. Ignore the error and continue.
+      // Mtab lookup can fail for transient mounts or race conditions.
+      // Ignore and continue with whatever the native call returns.
     }
   }
 
@@ -140,7 +141,7 @@ async function _getVolumeMetadata(
     remote,
   }) as VolumeMetadata;
 
-  // Backfill if blkid or gio failed us:
+  // Backfill if blkid failed us:
   if (isLinux && isNotBlank(device)) {
     // Sometimes blkid doesn't have the UUID in cache. Try to get it from
     // /dev/disk/by-uuid:
@@ -209,7 +210,7 @@ export async function getVolumeMetadataForPathImpl(
 
   // Linux/Windows: stat().dev is reliable (no firmlinks). Find the mount point
   // by comparing device IDs, using path prefix as a tiebreaker for bind mounts
-  // or GIO mounts that share the same device id.
+  // or GVfs/FUSE mounts that share the same device id.
   const mountPoint = await findMountPointByDeviceId(
     resolved,
     resolvedStat,
@@ -221,12 +222,18 @@ export async function getVolumeMetadataForPathImpl(
 }
 
 /**
- * Find the mount point for a resolved path using device ID matching.
+ * Find the mount point for a resolved path using device ID + path ancestry.
  * Used on Linux and Windows where stat().dev is reliable (no firmlinks).
  *
- * Compares device IDs of mount points against the target path's device ID,
- * using path prefix as a tiebreaker for bind mounts or GIO mounts that share
- * the same device id. The longest prefix match wins.
+ * Device ID filters out unrelated filesystems. Among same-device mount points,
+ * ancestor-path matches (mount point is a parent of `resolved`) are strongly
+ * preferred over device-only matches — GVfs/FUSE mounts on Linux can share
+ * the same device ID across unrelated volumes (e.g. multiple SMB shares
+ * under /run/user/.../gvfs/), so device ID alone is ambiguous. The longest
+ * ancestor wins.
+ *
+ * The device-only fallback (`deviceMatches`) exists for bind mounts where the
+ * canonical mount point may not be a path ancestor of the target.
  */
 export async function findMountPointByDeviceId(
   resolved: string,
@@ -235,10 +242,12 @@ export async function findMountPointByDeviceId(
   nativeFn: NativeBindingsFn,
 ): Promise<string> {
   const targetDev = resolvedStat.dev;
-  const mountPoints = await getVolumeMountPointsImpl(
-    { ...opts, includeSystemVolumes: true },
-    nativeFn,
-  );
+  const mountPoints =
+    opts.mountPoints ??
+    (await getVolumeMountPointsImpl(
+      { ...opts, includeSystemVolumes: true },
+      nativeFn,
+    ));
 
   const prefixMatches: string[] = [];
   const deviceMatches: string[] = [];
@@ -259,6 +268,8 @@ export async function findMountPointByDeviceId(
     }),
   );
 
+  // Prefer ancestor matches — they're unambiguous. Fall back to device-only
+  // matches only when the mount point isn't an ancestor (e.g. bind mounts).
   const candidates = prefixMatches.length > 0 ? prefixMatches : deviceMatches;
   if (candidates.length === 0) {
     throw new Error(

package/src/volume_mount_points.ts

@@ -51,7 +51,7 @@ async function _getVolumeMountPoints(
         );
         return points;
       })()
-    : getLinuxMountPoints(nativeFn, o));
+    : getLinuxMountPoints(o));
 
   debug("[getVolumeMountPoints] raw mount points: %o", raw);
 

package/scripts/setup-native.mjs

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-
-// scripts/setup-native.mjs
-
-// This script sets up the config.gypi file to include GIO support when available.
-// It should be run before building native modules with node-gyp.
-
-import { execSync } from "node:child_process";
-import { writeFileSync } from "node:fs";
-import { platform } from "node:os";
-import { argv } from "node:process";
-import { pathToFileURL } from "node:url";
-
-function hasGio() {
-  if (platform() !== "linux") return false;
-  try {
-    execSync("pkg-config --exists gio-2.0", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function configure() {
-  // Create a gyp config file that node-gyp will read
-  const config = {
-    variables: {
-      "enable_gio%": hasGio() ? "true" : "false",
-    },
-  };
-
-  const payload = JSON.stringify(config, null, 2);
-  writeFileSync("config.gypi", payload);
-}
-
-// If the script is run directly, call the configure function
-if (import.meta.url === pathToFileURL(argv[1]).href) {
-  configure();
-}

package/src/linux/gio_mount_points.cpp

@@ -1,80 +0,0 @@
-// src/linux/gio_mount_points.cpp
-#ifdef ENABLE_GIO
-
-#include "gio_mount_points.h"
-#include "../common/debug_log.h"
-#include "gio_utils.h"
-#include <gio/gio.h>
-#include <memory>
-#include <stdexcept>
-
-namespace FSMeta {
-namespace gio {
-
-GioMountPointsWorker::GioMountPointsWorker(
-    const Napi::Promise::Deferred &deferred)
-    : Napi::AsyncWorker(deferred.Env()), deferred_(deferred) {}
-
-GioMountPointsWorker::~GioMountPointsWorker() { mountPoints.clear(); }
-
-void GioMountPointsWorker::Execute() {
-  try {
-    DEBUG_LOG("[GioMountPoints] processing mounts");
-
-    // Use thread-safe g_unix_mounts_get() API
-    MountIterator::forEachMount([this](GUnixMountEntry *entry) {
-      // Get mount path and filesystem type from thread-safe Unix mount API
-      const char *mount_path = g_unix_mount_get_mount_path(entry);
-      const char *fs_type = g_unix_mount_get_fs_type(entry);
-
-      if (mount_path && fs_type) {
-        DEBUG_LOG("[GioMountPoints] found {mountPoint: %s, fsType: %s}",
-                  mount_path, fs_type);
-
-        MountPoint point{};
-        point.mountPoint = mount_path;
-        point.fstype = fs_type;
-        mountPoints.push_back(point);
-      } else {
-        DEBUG_LOG("[GioMountPoints] skipping mount with null path or fstype");
-      }
-
-      return true; // Continue iteration
-    });
-
-    DEBUG_LOG("[GioMountPoints] found %zu mount points", mountPoints.size());
-  } catch (const std::exception &e) {
-    DEBUG_LOG("[GioMountPoints] error: %s", e.what());
-    SetError(e.what());
-  }
-}
-
-void GioMountPointsWorker::OnOK() {
-  const Napi::HandleScope scope(Env());
-  const Napi::Array result = Napi::Array::New(Env());
-
-  for (size_t i = 0; i < mountPoints.size(); i++) {
-    const Napi::Object point = Napi::Object::New(Env());
-    point.Set("mountPoint", mountPoints[i].mountPoint);
-    point.Set("fstype", mountPoints[i].fstype);
-    result.Set(i, point);
-  }
-
-  deferred_.Resolve(result);
-}
-
-void GioMountPointsWorker::OnError(const Napi::Error &error) {
-  deferred_.Reject(error.Value());
-}
-
-Napi::Value GetMountPoints(Napi::Env env) {
-  auto deferred = Napi::Promise::Deferred::New(env);
-  auto *worker = new GioMountPointsWorker(deferred);
-  worker->Queue();
-  return deferred.Promise();
-}
-
-} // namespace gio
-} // namespace FSMeta
-
-#endif // ENABLE_GIO

package/src/linux/gio_mount_points.h

@@ -1,37 +0,0 @@
-// src/linux/gio_mount_points.h
-
-#pragma once
-
-#ifdef ENABLE_GIO
-
-#include "../common/volume_mount_points.h"
-#include <napi.h>
-#include <string>
-#include <vector>
-
-namespace FSMeta {
-namespace gio {
-
-/**
- * Get mount points asynchronously using GIO
- */
-Napi::Value GetMountPoints(Napi::Env env);
-
-class GioMountPointsWorker : public Napi::AsyncWorker {
-public:
-  explicit GioMountPointsWorker(const Napi::Promise::Deferred &deferred);
-  ~GioMountPointsWorker() override; // Add override specifier
-
-  void Execute() override;
-  void OnOK() override;
-  void OnError(const Napi::Error &error) override;
-
-private:
-  std::vector<MountPoint> mountPoints;
-  Napi::Promise::Deferred deferred_;
-};
-
-} // namespace gio
-} // namespace FSMeta
-
-#endif // ENABLE_GIO

package/src/linux/gio_utils.cpp

@@ -1,115 +0,0 @@
-// src/linux/gio_utils.cpp
-//
-// Thread-Safe Mount Enumeration for Linux
-//
-// This implementation uses g_unix_mounts_get() as the primary, thread-safe path
-// for enumerating mounts. GVolumeMonitor is optionally used for enrichment but
-// is NOT required for correct operation.
-//
-// IMPORTANT THREAD SAFETY NOTES:
-//
-// According to GIO documentation
-// (https://docs.gtk.org/gio/class.VolumeMonitor.html): "GVolumeMonitor is not
-// thread-default-context aware and so should not be used other than from the
-// main thread, with no thread-default-context active."
-//
-// However, g_unix_mounts_get() is explicitly thread-safe:
-// - Uses getmntent_r() when available (reentrant)
-// - Falls back to getmntent() with G_LOCK protection
-// See: https://gitlab.gnome.org/GNOME/glib/-/blob/main/gio/gunixmounts.c
-//
-// This design:
-// ✅ Primary path uses thread-safe g_unix_mounts_get()
-// ✅ Optional GVolumeMonitor enhancement (best-effort, may be skipped)
-// ✅ Fixes Finding #6 (thread safety violation)
-// ✅ Fixes Finding #7 (double-free risk with g_list_free_full)
-
-#ifdef ENABLE_GIO
-
-#include "gio_utils.h"
-#include "../common/debug_log.h"
-#include <gio/gio.h>
-#include <gio/gunixmounts.h>
-#include <memory>
-#include <stdexcept>
-
-namespace FSMeta {
-namespace gio {
-
-void MountIterator::forEachMount(const MountCallback &callback) {
-  // PRIMARY PATH: Thread-safe Unix mount enumeration
-  // g_unix_mounts_get() is documented as thread-safe and can be called
-  // from worker threads without violating GIO threading requirements.
-  GList *unix_mounts = g_unix_mounts_get(nullptr);
-
-  if (!unix_mounts) {
-    DEBUG_LOG("[gio::MountIterator::forEachMount] no mounts found");
-    return;
-  }
-
-  DEBUG_LOG("[gio::MountIterator::forEachMount] processing Unix mounts");
-
-  // Iterate over all Unix mounts
-  GList *current = unix_mounts;
-  bool should_continue = true;
-
-  while (current && should_continue) {
-    GUnixMountEntry *entry = static_cast<GUnixMountEntry *>(current->data);
-
-    if (!entry) {
-      DEBUG_LOG("[gio::MountIterator::forEachMount] Skipping null entry");
-      current = current->next;
-      continue;
-    }
-
-    try {
-      // Get mount path from thread-safe Unix mount API
-      const char *mount_path = g_unix_mount_get_mount_path(entry);
-      if (!mount_path) {
-        DEBUG_LOG(
-            "[gio::MountIterator::forEachMount] Skipping mount with null path");
-        current = current->next;
-        continue;
-      }
-
-      DEBUG_LOG("[gio::MountIterator::forEachMount] processing mount: %s",
-                mount_path);
-
-      // Invoke callback with Unix mount entry
-      // The callback receives the entry and can extract data using
-      // g_unix_mount_get_* functions
-      should_continue = callback(entry);
-
-    } catch (const std::exception &e) {
-      DEBUG_LOG("[gio::MountIterator::forEachMount] Exception during mount "
-                "processing: %s",
-                e.what());
-      // Clean up and re-throw
-      g_list_free_full(unix_mounts,
-                       reinterpret_cast<GDestroyNotify>(g_unix_mount_free));
-      throw;
-    }
-
-    current = current->next;
-  }
-
-  // Free list and all mount entries
-  // Each entry is freed with g_unix_mount_free() - no double-free risk
-  g_list_free_full(unix_mounts,
-                   reinterpret_cast<GDestroyNotify>(g_unix_mount_free));
-
-  DEBUG_LOG("[gio::MountIterator::forEachMount] completed");
-}
-
-// NOTE: tryGetMonitor() has been removed.
-//
-// GVolumeMonitor is NOT thread-safe and must only be used from the main thread.
-// See: https://docs.gtk.org/gio/class.VolumeMonitor.html
-//
-// Since all our code runs on Napi::AsyncWorker threads, using GVolumeMonitor
-// causes race conditions leading to GLib-GObject-CRITICAL errors.
-
-} // namespace gio
-} // namespace FSMeta
-
-#endif // ENABLE_GIO

package/src/linux/gio_utils.h

@@ -1,69 +0,0 @@
-// src/linux/gio_utils.h
-#pragma once
-
-#ifdef ENABLE_GIO
-
-#include <gio/gio.h>
-#include <gio/gunixmounts.h>
-#include <napi.h>
-#include <string>
-#include <vector>
-
-// Custom deleter for GObject types using g_object_unref
-template <typename T> struct GObjectDeleter {
-  void operator()(T *ptr) const {
-    if (ptr) {
-      g_object_unref(ptr);
-    }
-  }
-};
-
-// Custom deleter for g_free (used for strings from GIO APIs like
-// g_file_get_path)
-struct GFreeDeleter {
-  void operator()(void *ptr) const {
-    if (ptr) {
-      g_free(ptr);
-    }
-  }
-};
-
-// Smart pointer aliases for RAII management of GIO resources
-// These ensure proper cleanup even when exceptions occur
-template <typename T> using GObjectPtr = std::unique_ptr<T, GObjectDeleter<T>>;
-
-// Common GIO object types
-using GFilePtr = GObjectPtr<GFile>;
-using GMountPtr = GObjectPtr<GMount>;
-using GVolumePtr = GObjectPtr<GVolume>;
-using GVolumeMonitorPtr = GObjectPtr<GVolumeMonitor>;
-using GFileInfoPtr = GObjectPtr<GFileInfo>;
-
-// For strings allocated by GIO (g_file_get_path, g_file_get_uri, etc.)
-using GCharPtr = std::unique_ptr<char, GFreeDeleter>;
-
-namespace FSMeta {
-namespace gio {
-
-class MountIterator {
-public:
-  // Callback type for mount processing
-  // Receives GUnixMountEntry which provides thread-safe access to mount data
-  // Return true to continue iteration, false to stop
-  using MountCallback = std::function<bool(GUnixMountEntry *)>;
-
-  // Static method to iterate over mounts using thread-safe g_unix_mounts_get()
-  // This is safe to call from worker threads
-  static void forEachMount(const MountCallback &callback);
-
-  // NOTE: tryGetMonitor() has been removed because GVolumeMonitor is NOT
-  // thread-safe. See: https://docs.gtk.org/gio/class.VolumeMonitor.html
-};
-
-// Note: GioResource<T> has been removed in favor of GObjectPtr<T> above,
-// which provides equivalent RAII semantics with std::unique_ptr.
-
-} // namespace gio
-} // namespace FSMeta
-
-#endif // ENABLE_GIO

package/src/linux/gio_volume_metadata.cpp

@@ -1,81 +0,0 @@
-// src/linux/gio_volume_metadata.cpp
-
-#ifdef ENABLE_GIO
-
-#include "gio_volume_metadata.h"
-#include "../common/debug_log.h"
-#include "gio_utils.h"
-#include <gio/gio.h>
-#include <memory>
-#include <stdexcept>
-
-namespace FSMeta {
-namespace gio {
-
-void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
-  DEBUG_LOG("[gio::addMountMetadata] getting mount metadata for %s",
-            mountPoint.c_str());
-
-  bool found = false;
-
-  // PRIMARY PATH: Thread-safe Unix mount API
-  MountIterator::forEachMount([&](GUnixMountEntry *entry) {
-    const char *mount_path = g_unix_mount_get_mount_path(entry);
-    if (!mount_path || mountPoint != mount_path) {
-      return true; // Continue iteration
-    }
-
-    // Found matching mount point
-    DEBUG_LOG("[gio::addMountMetadata] found matching mount point: %s",
-              mount_path);
-    found = true;
-
-    // Get basic metadata from thread-safe Unix mount API
-    if (metadata.fstype.empty()) {
-      const char *fs_type = g_unix_mount_get_fs_type(entry);
-      if (fs_type) {
-        DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, fsType: %s}",
-                  mount_path, fs_type);
-        metadata.fstype = fs_type;
-      }
-    }
-
-    if (metadata.mountFrom.empty()) {
-      const char *device_path = g_unix_mount_get_device_path(entry);
-      if (device_path) {
-        DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, mountFrom: %s}",
-                  mount_path, device_path);
-        metadata.mountFrom = device_path;
-      }
-    }
-
-    // NOTE: GVolumeMonitor enrichment has been removed.
-    //
-    // According to GIO documentation:
-    // https://docs.gtk.org/gio/class.VolumeMonitor.html
-    // "GVolumeMonitor is not thread-default-context aware and so should not
-    // be used other than from the main thread, with no thread-default-context
-    // active."
-    //
-    // This function is called from Napi::AsyncWorker::Execute() which runs
-    // on a worker thread. Using GVolumeMonitor here causes race conditions
-    // leading to GLib-GObject-CRITICAL errors like:
-    //   "g_object_ref: assertion '!object_already_finalized' failed"
-    //
-    // The basic metadata (fstype, mountFrom) from g_unix_mounts_get() is
-    // sufficient and thread-safe. Rich metadata (label, mountName, uri) can
-    // be obtained from blkid or other thread-safe sources.
-
-    return false; // Stop iteration, we found our mount
-  });
-
-  if (!found) {
-    DEBUG_LOG("[gio::addMountMetadata] mount point %s not found",
-              mountPoint.c_str());
-  }
-}
-
-} // namespace gio
-} // namespace FSMeta
-
-#endif // ENABLE_GIO

package/src/linux/gio_volume_metadata.h

@@ -1,20 +0,0 @@
-// src/linux/gio_volume_metadata.h
-
-#pragma once
-
-#ifdef ENABLE_GIO
-
-#include "../common/volume_metadata.h"
-#include <string>
-
-namespace FSMeta {
-namespace gio {
-/**
- * Add metadata from GIO to the volume metadata
- */
-void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata);
-
-} // namespace gio
-} // namespace FSMeta
-
-#endif // ENABLE_GIO