@photostructure/fs-metadata 0.0.1

package/src/common/metadata_worker.h

@@ -0,0 +1,69 @@
+// src/common/metadata_worker.h
+#pragma once
+#include "./volume_metadata.h"
+#include <napi.h>
+
+namespace FSMeta {
+
+class MetadataWorkerBase : public Napi::AsyncWorker {
+protected:
+  std::string mountPoint;
+  VolumeMetadata metadata;
+  Napi::Promise::Deferred deferred_;
+
+  MetadataWorkerBase(const std::string &path,
+                     const Napi::Promise::Deferred &deferred)
+      : Napi::AsyncWorker(deferred.Env()), mountPoint(path),
+        deferred_(deferred) {}
+
+  void OnError(const Napi::Error &error) override {
+    deferred_.Reject(error.Value());
+  }
+
+  // Creates a JavaScript object from VolumeMetadata
+  Napi::Object CreateResultObject() {
+    auto env = Env();
+    auto result = Napi::Object::New(env);
+
+    // Match the current VolumeMetadata struct members
+    result.Set("label", metadata.label.empty()
+                            ? env.Null()
+                            : Napi::String::New(env, metadata.label));
+    result.Set("fileSystem", metadata.fileSystem.empty()
+                                 ? env.Null()
+                                 : Napi::String::New(env, metadata.fileSystem));
+    result.Set("size", Napi::Number::New(env, metadata.size));
+    result.Set("used", Napi::Number::New(env, metadata.used));
+    result.Set("available", Napi::Number::New(env, metadata.available));
+    result.Set("uuid", metadata.uuid.empty()
+                           ? env.Null()
+                           : Napi::String::New(env, metadata.uuid));
+    result.Set("mountFrom", metadata.mountFrom.empty()
+                                ? env.Null()
+                                : Napi::String::New(env, metadata.mountFrom));
+    result.Set("mountName", metadata.mountName.empty()
+                                ? env.Null()
+                                : Napi::String::New(env, metadata.mountName));
+    result.Set("uri", metadata.uri.empty()
+                          ? env.Null()
+                          : Napi::String::New(env, metadata.uri));
+    result.Set("status", Napi::String::New(env, metadata.status));
+
+    if (metadata.remote) {
+      result.Set("remote", Napi::Boolean::New(env, metadata.remote));
+    }
+    result.Set("remoteHost", metadata.remoteHost.empty()
+                                 ? env.Null()
+                                 : Napi::String::New(env, metadata.remoteHost));
+    result.Set("remoteShare",
+               metadata.remoteShare.empty()
+                   ? env.Null()
+                   : Napi::String::New(env, metadata.remoteShare));
+
+    return result;
+  };
+
+  void OnOK() override { deferred_.Resolve(CreateResultObject()); }
+}; // class MetadataWorkerBase
+
+} // namespace FSMeta

package/src/common/mount_point.h

@@ -0,0 +1,13 @@
+// src/common/mount_point.h
+#pragma once
+#include <napi.h>
+#include <string>
+
+namespace FSMeta {
+
+struct MountPoint {
+  std::string mountPoint;
+  std::string fstype;
+};
+
+} // namespace FSMeta

package/src/common/volume_metadata.h

@@ -0,0 +1,34 @@
+// src/common/volume_metadata.h
+#pragma once
+#include <napi.h>
+#include <string>
+
+namespace FSMeta {
+
+// Volume metadata structure
+struct VolumeMetadata {
+  std::string label;
+  std::string fileSystem;
+  double size;
+  double used;
+  double available;
+  std::string uuid;
+  std::string mountFrom;
+  std::string mountName;
+  std::string uri;
+  std::string status;
+  bool remote = false;
+  std::string remoteHost;
+  std::string remoteShare;
+};
+
+struct VolumeMetadataOptions {
+  uint32_t timeoutMs = 5000;
+  std::string device;
+};
+
+Napi::Value GetVolumeMetadata(const Napi::Env &env,
+                              const std::string &mountPoint,
+                              const Napi::Object &options);
+
+} // namespace FSMeta

package/src/common/volume_mount_points.h

@@ -0,0 +1,8 @@
+// src/common/volume_mount_points.h
+#pragma once
+#include <napi.h>
+#include <string>
+
+namespace FSMeta {
+Napi::Value GetVolumeMountPoints(Napi::Env env);
+}

package/src/darwin/fs_meta.h

@@ -0,0 +1,18 @@
+// src/darwin/fs_meta.h
+
+#pragma once
+
+#include "../common/error_utils.h"
+#include "../common/metadata_worker.h"
+#include "../common/mount_point.h"
+#include "../common/volume_mount_points.h"
+
+namespace FSMeta {
+
+// Forward declarations of the main interface functions
+Napi::Value GetVolumeMountPoints(Napi::Env env);
+Napi::Value GetVolumeMetadata(const Napi::Env &env,
+                              const std::string &mountPoint,
+                              const Napi::Object &options);
+
+} // namespace FSMeta

package/src/darwin/volume_metadata.cpp

@@ -0,0 +1,235 @@
+// src/darwin/volume_metadata.cpp
+
+#include "./fs_meta.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <DiskArbitration/DiskArbitration.h>
+#include <IOKit/IOBSD.h>
+#include <IOKit/storage/IOMedia.h>
+#include <IOKit/storage/IOStorageProtocolCharacteristics.h>
+#include <memory>
+#include <string>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/statvfs.h>
+
+namespace FSMeta {
+
+// Helper function to convert CFString to std::string
+static std::string CFStringToString(CFStringRef cfString) {
+  if (!cfString) {
+    return "";
+  }
+
+  CFIndex length = CFStringGetLength(cfString);
+  CFIndex maxSize =
+      CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
+  std::string result(maxSize, '\0');
+
+  if (!CFStringGetCString(cfString, &result[0], maxSize,
+                          kCFStringEncodingUTF8)) {
+    return "";
+  }
+
+  result.resize(strlen(result.c_str()));
+  return result;
+}
+
+// Improved CFReleaser with proper Core Foundation support
+template <typename T> class CFReleaser {
+private:
+  T ref_;
+
+public:
+  explicit CFReleaser(T ref = nullptr) noexcept : ref_(ref) {}
+
+  // Delete copy operations
+  CFReleaser(const CFReleaser &) = delete;
+  CFReleaser &operator=(const CFReleaser &) = delete;
+
+  // Move operations
+  CFReleaser(CFReleaser &&other) noexcept : ref_(other.ref_) {
+    other.ref_ = nullptr;
+  }
+
+  CFReleaser &operator=(CFReleaser &&other) noexcept {
+    if (this != &other) {
+      reset();
+      ref_ = other.ref_;
+      other.ref_ = nullptr;
+    }
+    return *this;
+  }
+
+  ~CFReleaser() { reset(); }
+
+  void reset(T ref = nullptr) {
+    if (ref_) {
+      CFRelease(ref_);
+    }
+    ref_ = ref;
+  }
+
+  // Implicit conversion operator for Core Foundation APIs
+  operator T() const noexcept { return ref_; }
+
+  T get() const noexcept { return ref_; }
+  bool isValid() const noexcept { return ref_ != nullptr; }
+
+  // Release ownership
+  T release() noexcept {
+    T temp = ref_;
+    ref_ = nullptr;
+    return temp;
+  }
+};
+
+class GetVolumeMetadataWorker : public MetadataWorkerBase {
+public:
+  GetVolumeMetadataWorker(const std::string &path,
+                          const Napi::Promise::Deferred &deferred)
+      : MetadataWorkerBase(path, deferred) {
+
+    if (path.empty()) {
+      throw FSException("Mount point path cannot be empty");
+    }
+  }
+
+  void Execute() override {
+    try {
+      if (!GetBasicVolumeInfo()) {
+        return;
+      }
+      GetDiskArbitrationInfo();
+    } catch (const std::exception &e) {
+      SetError(e.what());
+    }
+  }
+
+private:
+  bool GetBasicVolumeInfo() {
+    struct statvfs vfs;
+    struct statfs fs;
+
+    if (statvfs(mountPoint.c_str(), &vfs) != 0) {
+      SetError(CreateErrorMessage("statvfs", errno));
+      return false;
+    }
+
+    if (statfs(mountPoint.c_str(), &fs) != 0) {
+      SetError(CreateErrorMessage("statfs", errno));
+      return false;
+    }
+
+    // Calculate sizes using uint64_t to prevent overflow
+    const uint64_t blockSize = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;
+    const uint64_t totalBlocks = vfs.f_blocks;
+    const uint64_t availBlocks = vfs.f_bavail;
+    const uint64_t freeBlocks = vfs.f_bfree;
+
+    // Check for overflow before multiplication
+    if (blockSize > 0 &&
+        totalBlocks > std::numeric_limits<uint64_t>::max() / blockSize) {
+      SetError("Volume size calculation would overflow");
+      return false;
+    }
+
+    metadata.size = static_cast<double>(blockSize * totalBlocks);
+    metadata.available = static_cast<double>(blockSize * availBlocks);
+    metadata.used = static_cast<double>(blockSize * (totalBlocks - freeBlocks));
+
+    metadata.fileSystem = fs.f_fstypename;
+    metadata.mountFrom = fs.f_mntfromname;
+    metadata.mountName = fs.f_mntonname;
+    metadata.status = "ready";
+
+    return true;
+  }
+
+  void GetDiskArbitrationInfo() {
+    CFReleaser<DASessionRef> session(DASessionCreate(kCFAllocatorDefault));
+    if (!session.isValid()) {
+      metadata.status = "partial";
+      return;
+    }
+
+    // Schedule session with RunLoop
+    DASessionScheduleWithRunLoop(session.get(), CFRunLoopGetCurrent(),
+                                 kCFRunLoopDefaultMode);
+
+    // RAII cleanup for RunLoop scheduling
+    struct RunLoopCleaner {
+      DASessionRef session;
+      explicit RunLoopCleaner(DASessionRef s) : session(s) {}
+      ~RunLoopCleaner() {
+        DASessionUnscheduleFromRunLoop(session, CFRunLoopGetCurrent(),
+                                       kCFRunLoopDefaultMode);
+      }
+    } runLoopCleaner(session.get());
+
+    CFReleaser<DADiskRef> disk(DADiskCreateFromBSDName(
+        kCFAllocatorDefault, session.get(), metadata.mountFrom.c_str()));
+
+    if (!disk.isValid()) {
+      metadata.status = "partial";
+      return;
+    }
+
+    CFReleaser<CFDictionaryRef> description(DADiskCopyDescription(disk.get()));
+    if (!description.isValid()) {
+      metadata.status = "partial";
+      return;
+    }
+
+    ProcessDiskDescription(description.get());
+  }
+
+  void ProcessDiskDescription(CFDictionaryRef description) {
+    // Get volume name/label
+    if (CFStringRef volumeName = (CFStringRef)CFDictionaryGetValue(
+            description, kDADiskDescriptionVolumeNameKey)) {
+      metadata.label = CFStringToString(volumeName);
+    }
+
+    // Get UUID
+    if (CFUUIDRef uuid = (CFUUIDRef)CFDictionaryGetValue(
+            description, kDADiskDescriptionVolumeUUIDKey)) {
+      CFReleaser<CFStringRef> uuidString(
+          CFUUIDCreateString(kCFAllocatorDefault, uuid));
+      if (uuidString.isValid()) {
+        metadata.uuid = CFStringToString(uuidString.get());
+      }
+    }
+
+    ProcessNetworkVolume(description);
+  }
+
+  void ProcessNetworkVolume(CFDictionaryRef description) {
+    CFBooleanRef isNetworkVolume = (CFBooleanRef)CFDictionaryGetValue(
+        description, kDADiskDescriptionVolumeNetworkKey);
+
+    metadata.remote = CFBooleanGetValue(isNetworkVolume);
+    CFURLRef url = (CFURLRef)CFDictionaryGetValue(
+        description, kDADiskDescriptionVolumePathKey);
+    if (!url) {
+      return;
+    }
+
+    CFStringRef urlString = CFURLGetString(url);
+    if (!urlString) {
+      return;
+    }
+    metadata.uri = CFStringToString(urlString);
+  }
+};
+
+Napi::Value GetVolumeMetadata(const Napi::Env &env,
+                              const std::string &mountPoint,
+                              const Napi::Object &options) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  auto *worker = new GetVolumeMetadataWorker(mountPoint, deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+} // namespace FSMeta

package/src/darwin/volume_mount_points.cpp

@@ -0,0 +1,65 @@
+// src/darwin/volume_mount_points.cpp
+
+#include "./fs_meta.h"
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <vector>
+
+namespace FSMeta {
+
+class GetVolumeMountPointsWorker : public Napi::AsyncWorker {
+public:
+  GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred)
+      : Napi::AsyncWorker(deferred.Env()), deferred_(deferred) {}
+
+  void Execute() override {
+    try {
+      struct statfs *mntbufp;
+      int count = getmntinfo(&mntbufp, MNT_WAIT);
+
+      if (count <= 0) {
+        throw std::runtime_error("Failed to get mount information");
+      }
+
+      for (int i = 0; i < count; i++) {
+        MountPoint point;
+        point.mountPoint = mntbufp[i].f_mntonname;
+        point.fstype = mntbufp[i].f_fstypename;
+        mountPoints.push_back(point);
+      }
+    } catch (const std::exception &e) {
+      SetError(e.what());
+    }
+  }
+
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    Napi::Array result = Napi::Array::New(Env());
+
+    for (size_t i = 0; i < mountPoints.size(); i++) {
+      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 OnError(const Napi::Error &error) override {
+    deferred_.Reject(error.Value());
+  }
+
+private:
+  std::vector<MountPoint> mountPoints;
+  Napi::Promise::Deferred deferred_;
+};
+
+Napi::Value GetVolumeMountPoints(Napi::Env env) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  auto *worker = new GetVolumeMountPointsWorker(deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+} // namespace FSMeta

package/src/linux/blkid_cache.cpp

@@ -0,0 +1,42 @@
+// src/linux/blkid_cache.cpp
+#include "blkid_cache.h"
+#include <stdexcept>
+
+namespace FSMeta {
+
+// Define the static mutex
+std::mutex BlkidCache::mutex_;
+
+// Constructor: Initializes the blkid cache with proper error handling
+BlkidCache::BlkidCache() : cache_(nullptr) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (blkid_get_cache(&cache_, nullptr) != 0) {
+    throw std::runtime_error("Failed to initialize blkid cache");
+  }
+}
+
+// Destructor: Safely releases the blkid cache resource
+BlkidCache::~BlkidCache() {
+  if (cache_) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    try {
+      blkid_put_cache(cache_);
+      cache_ = nullptr; // Avoid double-release
+    } catch (const std::exception &e) {
+      // Optional: Log error during cache cleanup
+      // std::cerr << "Error while releasing blkid cache: " << e.what()
+      //           << std::endl;
+    }
+  }
+}
+
+// Accessor for blkid cache
+blkid_cache BlkidCache::get() {
+  if (!cache_) {
+    throw std::runtime_error(
+        "blkid cache is uninitialized or has been released");
+  }
+  return cache_;
+}
+
+} // namespace FSMeta

package/src/linux/blkid_cache.h

@@ -0,0 +1,27 @@
+// src/linux/blkid_cache.h
+#pragma once
+#include <blkid/blkid.h>
+#include <mutex>
+
+namespace FSMeta {
+
+// Thread-safe helper class for RAII handling of blkid cache
+class BlkidCache {
+private:
+  static std::mutex mutex_;
+  blkid_cache cache_;
+
+public:
+  BlkidCache();
+  ~BlkidCache();
+
+  // Returns the blkid cache pointer
+  blkid_cache get();
+
+  operator bool() const { return cache_ != nullptr; }
+
+  BlkidCache(const BlkidCache &) = delete;
+  BlkidCache &operator=(const BlkidCache &) = delete;
+};
+
+} // namespace FSMeta

package/src/linux/gio_utils.cpp

@@ -0,0 +1,151 @@
+#ifdef ENABLE_GIO
+
+#include "gio_utils.h"
+#include "gio_worker.h"
+#include <gio/gio.h>
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+
+namespace FSMeta {
+namespace gio {
+
+// Custom deleter for GObject types
+struct GObjectDeleter {
+  void operator()(void *ptr) const {
+    if (ptr) {
+      g_object_unref(ptr);
+    }
+  }
+};
+
+// Type aliases for common GObject smart pointers
+using GVolumeMonitorPtr = std::unique_ptr<GVolumeMonitor, GObjectDeleter>;
+using GObjectPtr = std::unique_ptr<GObject, GObjectDeleter>;
+using GFilePtr = std::unique_ptr<GFile, GObjectDeleter>;
+using GVolumePtr = std::unique_ptr<GVolume, GObjectDeleter>;
+using GMountPtr = std::unique_ptr<GMount, GObjectDeleter>;
+using GUriPtr = std::unique_ptr<GUri, GObjectDeleter>;
+
+Napi::Value GetMountPoints(Napi::Env env) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  auto *worker = new GioMountPointsWorker(deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
+
+  GVolumeMonitor *monitor = g_volume_monitor_get();
+  if (!monitor) {
+    return;
+  }
+
+  std::unique_ptr<GVolumeMonitor, GObjectDeleter> monitor_guard(monitor);
+  GList *mounts = g_volume_monitor_get_mounts(monitor);
+  if (!mounts) {
+    return;
+  }
+
+  for (GList *l = mounts; l != nullptr; l = l->next) {
+    GMount *mount = G_MOUNT(l->data);
+    if (!mount) {
+      continue;
+    }
+
+    GFile *root = g_mount_get_root(mount);
+    if (!root) {
+      continue;
+    }
+
+    char *path = g_file_get_path(root);
+
+    if (path && mountPoint == path) {
+
+      // Get volume name
+      GVolume *volume = g_mount_get_volume(mount);
+      if (volume) {
+        char *name = g_volume_get_name(volume);
+        if (name) {
+          metadata.label = name;
+          g_free(name);
+        }
+        g_object_unref(volume);
+      }
+
+      // Get mount name (can include filesystem type info)
+      char *mount_name = g_mount_get_name(mount);
+      if (mount_name) {
+        g_free(mount_name);
+      }
+
+      // Get location and URI
+      GFile *location = g_mount_get_default_location(mount);
+      if (location) {
+
+        // Try different URI methods
+        char *uri = g_file_get_uri(location);
+        char *parse_name = g_file_get_parse_name(location);
+
+        if (uri) {
+          metadata.uri = uri;
+
+          // Parse URI for remote details
+          GError *error = nullptr;
+          GUri *parsed_uri = g_uri_parse(uri, G_URI_FLAGS_NONE, &error);
+          if (parsed_uri) {
+            const char *scheme = g_uri_get_scheme(parsed_uri);
+
+            if (scheme && strcmp(scheme, "file") != 0) {
+              metadata.remote = true;
+              metadata.fileSystem = scheme;
+
+              const char *host = g_uri_get_host(parsed_uri);
+              const char *path = g_uri_get_path(parsed_uri);
+
+              if (host)
+                metadata.remoteHost = host;
+              if (path && path[0] == '/')
+                metadata.remoteShare = path + 1;
+            }
+            g_uri_unref(parsed_uri);
+          } else {
+            if (error) {
+              g_error_free(error);
+            }
+          }
+          g_free(uri);
+        }
+
+        if (parse_name) {
+          g_free(parse_name);
+        }
+        g_object_unref(location);
+      }
+
+      // Try additional methods to get filesystem info
+      if (metadata.fileSystem.empty()) {
+        GDrive *drive = g_mount_get_drive(mount);
+        if (drive) {
+          // Try to get unix device path
+          char *unix_device = g_drive_get_identifier(
+              drive, G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE);
+          if (unix_device) {
+            g_free(unix_device);
+          }
+          g_object_unref(drive);
+        }
+      }
+      break;
+    }
+    g_object_unref(root);
+    g_free(path);
+  }
+
+  g_list_free_full(mounts, g_object_unref);
+}
+
+} // namespace gio
+} // namespace FSMeta
+
+#endif // ENABLE_GIO

package/src/linux/gio_utils.h

@@ -0,0 +1,27 @@
+// src/linux/gio_utils.h
+#pragma once
+
+#ifdef ENABLE_GIO
+
+#include "../common/volume_metadata.h"
+#include <napi.h>
+#include <string>
+#include <vector>
+
+namespace FSMeta {
+namespace gio {
+
+/**
+ * Get mount points asynchronously using GIO
+ */
+Napi::Value GetMountPoints(Napi::Env env);
+
+/**
+ * Add metadata from GIO to the volume metadata
+ */
+void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata);
+
+} // namespace gio
+} // namespace FSMeta
+
+#endif // ENABLE_GIO