@photostructure/fs-metadata 0.0.1 → 0.1.0

package/src/windows/drive_status.h

@@ -0,0 +1,227 @@
+// src/windows/drive_status.h
+
+#pragma once
+#include "../common/debug_log.h"
+#include <memory>
+#include <string>
+#include <vector>
+#include <windows.h>
+
+namespace FSMeta {
+
+enum class DriveStatus {
+  Healthy,
+  Timeout,
+  Inaccessible,
+  Disconnected,
+  Unknown
+};
+
+inline std::string DriveStatusToString(DriveStatus status) {
+  switch (status) {
+  case DriveStatus::Healthy:
+    return "healthy";
+  case DriveStatus::Timeout:
+    return "timeout";
+  case DriveStatus::Inaccessible:
+    return "inaccessible";
+  case DriveStatus::Disconnected:
+    return "disconnected";
+  default:
+    return "unknown";
+  }
+}
+
+class IOOperation {
+private:
+  HANDLE completionEvent;
+  DriveStatus result;
+  std::string path;
+  DWORD threadId;
+  volatile bool shouldTerminate;
+  HANDLE threadHandle; // Store thread handle as member
+
+public:
+  IOOperation()
+      : result(DriveStatus::Unknown), threadId(0), shouldTerminate(false),
+        threadHandle(NULL) {
+    completionEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+  }
+
+  ~IOOperation() {
+    if (completionEvent) {
+      CloseHandle(completionEvent);
+    }
+    CleanupThread();
+  }
+
+  void CleanupThread() {
+    if (threadHandle) {
+      DEBUG_LOG("[IOOperation] Cleaning up thread %lu", threadId);
+      // Signal termination
+      shouldTerminate = true;
+
+      // Give thread chance to exit gracefully
+      if (WaitForSingleObject(threadHandle, 100) != WAIT_OBJECT_0) {
+        DEBUG_LOG("[IOOperation] Force terminating thread %lu", threadId);
+        TerminateThread(threadHandle, 1);
+      }
+
+      CloseHandle(threadHandle);
+      threadHandle = NULL;
+      DEBUG_LOG("[IOOperation] Thread cleanup complete");
+    }
+  }
+
+  static DWORD WINAPI WorkerThread(LPVOID param) {
+    IOOperation *self = static_cast<IOOperation *>(param);
+    std::string searchPath = self->path + "*";
+    HANDLE findHandle = INVALID_HANDLE_VALUE;
+    WIN32_FIND_DATAA findData;
+
+    DEBUG_LOG("[WorkerThread] Starting search on path: %s", searchPath.c_str());
+
+    findHandle = FindFirstFileExA(
+        searchPath.c_str(), FindExInfoBasic, &findData, FindExSearchNameMatch,
+        NULL, FIND_FIRST_EX_LARGE_FETCH | FIND_FIRST_EX_ON_DISK_ENTRIES_ONLY);
+
+    if (findHandle == INVALID_HANDLE_VALUE) {
+      self->result = self->MapErrorToDriveStatus(GetLastError());
+      DEBUG_LOG("[WorkerThread] Search failed with error: %lu", GetLastError());
+    } else {
+      self->result = DriveStatus::Healthy;
+      FindClose(findHandle);
+      DEBUG_LOG("[WorkerThread] Search completed successfully");
+    }
+
+    SetEvent(self->completionEvent);
+    DEBUG_LOG("[WorkerThread] Thread %lu exiting", self->threadId);
+    return 0;
+  }
+
+  DriveStatus CheckDriveWithTimeout(const std::string &checkPath,
+                                    DWORD timeoutMs) {
+    DEBUG_LOG("[CheckDriveStatus] Starting check for: %s timeout: %lu ms",
+              checkPath.c_str(), timeoutMs);
+
+    // Cleanup any previous thread
+    CleanupThread();
+
+    path = checkPath;
+    ResetEvent(completionEvent);
+    shouldTerminate = false;
+
+    threadHandle = CreateThread(NULL, 0, WorkerThread, this, 0, &threadId);
+    if (!threadHandle) {
+      DEBUG_LOG("[CheckDriveStatus] Failed to create thread");
+      return DriveStatus::Unknown;
+    }
+
+    DEBUG_LOG("[CheckDriveStatus] Created thread %lu", threadId);
+    DWORD waitResult = WaitForSingleObject(threadHandle, timeoutMs);
+
+    if (waitResult == WAIT_TIMEOUT) {
+      DEBUG_LOG("[CheckDriveStatus] Thread %lu timed out after %lu ms",
+                threadId, timeoutMs);
+      CleanupThread();
+      return DriveStatus::Timeout;
+    }
+
+    DEBUG_LOG("[CheckDriveStatus] Thread %lu completed normally", threadId);
+    CloseHandle(threadHandle);
+    DEBUG_LOG("[CheckDriveStatus] CloseHandle %lu completed", threadId);
+    threadHandle = NULL;
+    return result;
+  }
+
+private:
+  DriveStatus MapErrorToDriveStatus(DWORD error) {
+    switch (error) {
+    case ERROR_FILE_NOT_FOUND:
+    case ERROR_PATH_NOT_FOUND:
+    case ERROR_ACCESS_DENIED:
+    case ERROR_LOGON_FAILURE:
+      return DriveStatus::Inaccessible;
+
+    case ERROR_BAD_NET_NAME:
+    case ERROR_NETWORK_UNREACHABLE:
+    case ERROR_NOT_CONNECTED:
+    case ERROR_NETWORK_ACCESS_DENIED:
+    case ERROR_BAD_NETPATH:
+      return DriveStatus::Disconnected;
+
+    default:
+      return DriveStatus::Unknown;
+    }
+  }
+};
+
+class ParallelDriveStatus {
+private:
+  struct PendingCheck {
+    std::string path;
+    std::unique_ptr<IOOperation> op;
+    DWORD timeoutMs;
+    DriveStatus status;
+  };
+
+  std::vector<std::unique_ptr<PendingCheck>> pending_;
+
+public:
+  void Submit(const std::string &path, DWORD timeoutMs = 1000) {
+    auto check = std::make_unique<PendingCheck>();
+    check->path = path;
+    check->op = std::make_unique<IOOperation>();
+    check->timeoutMs = timeoutMs;
+    check->status = DriveStatus::Unknown;
+
+    DEBUG_LOG("[ParallelDriveStatus] Submitting check for: %s", path.c_str());
+    pending_.push_back(std::move(check));
+  }
+
+  std::vector<DriveStatus> WaitForResults() {
+    std::vector<DriveStatus> results;
+    results.reserve(pending_.size());
+
+    // Start all operations
+    for (auto &check : pending_) {
+      check->status =
+          check->op->CheckDriveWithTimeout(check->path, check->timeoutMs);
+    }
+
+    // Collect results in original order
+    for (auto &check : pending_) {
+      DEBUG_LOG("[ParallelDriveStatus] Result for %s: %s", check->path.c_str(),
+                DriveStatusToString(check->status).c_str());
+      results.push_back(check->status);
+    }
+
+    pending_.clear();
+    return results;
+  }
+};
+
+// Update CheckDriveStatus to support checking multiple paths
+inline std::vector<DriveStatus>
+CheckDriveStatus(const std::vector<std::string> &paths,
+                 DWORD timeoutMs = 1000) {
+  try {
+    ParallelDriveStatus checker;
+    for (const auto &path : paths) {
+      checker.Submit(path, timeoutMs);
+    }
+    return checker.WaitForResults();
+  } catch (...) {
+    DEBUG_LOG("[CheckDriveStatus] caught unexpected exception");
+    return std::vector<DriveStatus>(paths.size(), DriveStatus::Unknown);
+  }
+}
+
+// Keep single path version for backwards compatibility
+inline DriveStatus CheckDriveStatus(const std::string &path,
+                                    DWORD timeoutMs = 1000) {
+  std::vector<std::string> paths{path};
+  return CheckDriveStatus(paths, timeoutMs)[0];
+}
+
+} // namespace FSMeta

package/src/windows/error_utils.h

@@ -11,12 +11,33 @@ class FSException : public std::runtime_error {
 public:
   explicit FSException(const std::string &message)
       : std::runtime_error(message) {}
-};
 
-inline std::string CreateErrorMessage(const char *operation, DWORD error) {
-  std::ostringstream oss;
-  oss << operation << " failed with error: " << error;
-  return oss.str();
-}
+  FSException(const std::string &operation, DWORD errorCode)
+      : std::runtime_error(FormatWindowsError(operation, errorCode)) {}
+
+private:
+  static std::string FormatWindowsError(const std::string &operation,
+                                        DWORD error) {
+    if (error == 0) {
+      return operation + " failed with an unknown error";
+    }
+
+    LPVOID messageBuffer;
+    size_t size = FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPSTR)&messageBuffer, 0, NULL);
+
+    if (size == 0 || !messageBuffer) {
+      return operation + " failed with error code: " + std::to_string(error);
+    }
+
+    std::string errorMessage((LPSTR)messageBuffer, size);
+    LocalFree(messageBuffer);
+
+    return operation + " failed: " + errorMessage;
+  }
+};
 
 } // namespace FSMeta

package/src/windows/fs_meta.h

@@ -1,43 +1,13 @@
 // src/windows/fs_meta.h
+
 #pragma once
 #include "../common/volume_metadata.h"
 #include "../common/volume_mount_points.h"
-#include "./error_utils.h"
-#include <napi.h>
-
-#include <string>
+#include <windows.h> // for MAX_PATH
 
 namespace FSMeta {
 
 constexpr size_t ERROR_BUFFER_SIZE = 256;
-constexpr DWORD BUFFER_SIZE = MAX_PATH + 1;
-
-enum DriveStatus {
-  Unknown,
-  Unavailable,
-  Healthy,
-  Disconnected,
-  Error,
-  NoMedia
-};
-
-inline const char *DriveStatusToString(DriveStatus status) {
-  switch (status) {
-  case Unknown:
-    return "unknown";
-  case Unavailable:
-    return "unavailable";
-  case Healthy:
-    return "healthy";
-  case Disconnected:
-    return "disconnected";
-  case Error:
-    return "error";
-  case NoMedia:
-    return "no_media";
-  default:
-    return "unknown";
-  }
-}
+constexpr size_t BUFFER_SIZE = MAX_PATH + 1;
 
 } // namespace FSMeta

package/src/windows/hidden.cpp

@@ -0,0 +1,160 @@
+// src/windows/hidden.cpp
+#include "hidden.h"
+#include "error_utils.h"
+#include <windows.h>
+
+namespace FSMeta {
+
+namespace {
+// Utility class for path conversion
+class PathConverter {
+public:
+  static std::wstring ToWString(const std::string &path) {
+    if (path.empty()) {
+      return std::wstring();
+    }
+
+    // Pre-calculate required buffer size
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, path.c_str(),
+                                   static_cast<int>(path.length()), nullptr, 0);
+    if (wlen == 0) {
+      throw FSException("Path conversion", GetLastError());
+    }
+
+    // Reserve exact size needed
+    std::wstring wpath(wlen, 0);
+    if (!MultiByteToWideChar(CP_UTF8, 0, path.c_str(),
+                             static_cast<int>(path.length()), &wpath[0],
+                             wlen)) {
+      throw FSException("Path conversion", GetLastError());
+    }
+    return wpath;
+  }
+};
+
+// RAII wrapper for file attributes
+class FileAttributeHandler {
+  const std::wstring &path;
+  DWORD attributes;
+
+public:
+  explicit FileAttributeHandler(const std::wstring &p)
+      : path(p), attributes(GetFileAttributesW(p.c_str())) {
+    if (attributes == INVALID_FILE_ATTRIBUTES) {
+      throw FSException("GetFileAttributes", GetLastError());
+    }
+  }
+
+  bool isHidden() const { return (attributes & FILE_ATTRIBUTE_HIDDEN) != 0; }
+
+  void setHidden(bool value) {
+    DWORD newAttrs = value ? (attributes | FILE_ATTRIBUTE_HIDDEN)
+                           : (attributes & ~FILE_ATTRIBUTE_HIDDEN);
+
+    if (!SetFileAttributesW(path.c_str(), newAttrs)) {
+      throw FSException("SetFileAttributes", GetLastError());
+    }
+    attributes = newAttrs;
+  }
+};
+} // anonymous namespace
+
+class GetHiddenWorker : public Napi::AsyncWorker {
+  const std::string path;
+  bool result;
+  Napi::Promise::Deferred deferred;
+
+public:
+  GetHiddenWorker(Napi::Env env, std::string p, Napi::Promise::Deferred def)
+      : Napi::AsyncWorker(env), path(std::move(p)), deferred(std::move(def)) {}
+
+  void Execute() override {
+    try {
+      auto wpath = PathConverter::ToWString(path);
+      FileAttributeHandler handler(wpath);
+      result = handler.isHidden();
+    } catch (const FSException &e) {
+      SetError(e.what());
+    } catch (const std::exception &e) {
+      SetError(std::string("Unexpected error: ") + e.what());
+    }
+  }
+
+  void OnOK() override { deferred.Resolve(Napi::Boolean::New(Env(), result)); }
+
+  void OnError(const Napi::Error &e) override { deferred.Reject(e.Value()); }
+};
+
+class SetHiddenWorker : public Napi::AsyncWorker {
+  const std::string path;
+  const bool value;
+  Napi::Promise::Deferred deferred;
+
+public:
+  SetHiddenWorker(Napi::Env env, std::string p, bool v,
+                  Napi::Promise::Deferred def)
+      : Napi::AsyncWorker(env), path(std::move(p)), value(v),
+        deferred(std::move(def)) {}
+
+  void Execute() override {
+    try {
+      auto wpath = PathConverter::ToWString(path);
+      FileAttributeHandler handler(wpath);
+      handler.setHidden(value);
+    } catch (const FSException &e) {
+      SetError(e.what());
+    } catch (const std::exception &e) {
+      SetError(std::string("Unexpected error: ") + e.what());
+    }
+  }
+
+  void OnOK() override { deferred.Resolve(Napi::Boolean::New(Env(), true)); }
+
+  void OnError(const Napi::Error &e) override { deferred.Reject(e.Value()); }
+};
+
+Napi::Promise GetHiddenAttribute(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  auto deferred = Napi::Promise::Deferred::New(env);
+
+  try {
+    if (info.Length() < 1 || !info[0].IsString()) {
+      throw Napi::TypeError::New(env, "String path expected");
+    }
+
+    std::string path = info[0].As<Napi::String>();
+    auto *worker =
+        new GetHiddenWorker(env, std::move(path), std::move(deferred));
+    worker->Queue();
+
+    return deferred.Promise();
+  } catch (const Napi::Error &e) {
+    deferred.Reject(e.Value());
+    return deferred.Promise();
+  }
+}
+
+Napi::Promise SetHiddenAttribute(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  auto deferred = Napi::Promise::Deferred::New(env);
+
+  try {
+    if (info.Length() < 2 || !info[0].IsString() || !info[1].IsBoolean()) {
+      throw Napi::TypeError::New(env, "String path and boolean value expected");
+    }
+
+    std::string path = info[0].As<Napi::String>();
+    bool value = info[1].As<Napi::Boolean>();
+
+    auto *worker =
+        new SetHiddenWorker(env, std::move(path), value, std::move(deferred));
+    worker->Queue();
+
+    return deferred.Promise();
+  } catch (const Napi::Error &e) {
+    deferred.Reject(e.Value());
+    return deferred.Promise();
+  }
+}
+
+} // namespace FSMeta

package/src/windows/hidden.h

@@ -0,0 +1,3 @@
+// src/windows/hidden.h
+#pragma once
+#include "../common/hidden.h"

package/src/windows/string.h

@@ -0,0 +1,48 @@
+// src/windows/string.h
+
+#pragma once
+#include <string>
+#include <windows.h>
+
+namespace FSMeta {
+
+inline std::string WideToUtf8(const WCHAR *wide) {
+  if (!wide || wide[0] == 0)
+    return "";
+
+  int size =
+      WideCharToMultiByte(CP_UTF8, 0, wide, -1, nullptr, 0, nullptr, nullptr);
+  if (size <= 0)
+    return "";
+
+  std::string result(size - 1, 0);
+  WideCharToMultiByte(CP_UTF8, 0, wide, -1, &result[0], size, nullptr, nullptr);
+  return result;
+}
+
+class PathConverter {
+public:
+  static std::wstring ToWString(const std::string &path) {
+    if (path.empty()) {
+      return L"";
+    }
+
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, path.c_str(),
+                                   static_cast<int>(path.length()), nullptr, 0);
+
+    if (wlen == 0) {
+      return L"";
+    }
+
+    std::wstring wpath(wlen, 0);
+    if (!MultiByteToWideChar(CP_UTF8, 0, path.c_str(),
+                             static_cast<int>(path.length()), &wpath[0],
+                             wlen)) {
+      return L"";
+    }
+
+    return wpath;
+  }
+};
+
+} // namespace FSMeta

package/src/windows/system_volume.h

@@ -0,0 +1,63 @@
+// src/windows/system_volume.h
+#pragma once
+#include "../common/debug_log.h"
+#include "string.h"
+#include <PathCch.h>
+#include <shlobj.h> // For SHGetFolderPathW and CSIDL constants
+#include <string>
+#include <windows.h>
+
+// If FILE_SUPPORTS_SYSTEM_PATHS is not defined (older SDK)
+#ifndef FILE_SUPPORTS_SYSTEM_PATHS
+#define FILE_SUPPORTS_SYSTEM_PATHS 0x00100000
+#endif
+
+#ifndef FILE_SUPPORTS_SYSTEM_FILES
+#define FILE_SUPPORTS_SYSTEM_FILES 0x00200000
+#endif
+
+namespace FSMeta {
+
+inline bool IsSystemVolume(const std::wstring &drive) {
+  WCHAR systemRoot[MAX_PATH];
+  if (SUCCEEDED(
+          SHGetFolderPathW(nullptr, CSIDL_WINDOWS, nullptr, 0, systemRoot))) {
+    WCHAR rootPath[4];
+    wcsncpy_s(rootPath, systemRoot, 3);
+    rootPath[3] = '\0';
+
+    if (_wcsnicmp(drive.c_str(), rootPath, 2) == 0) {
+      DEBUG_LOG("[IsSystemVolume] %ls is a system volume", drive.c_str());
+      return true;
+    }
+  }
+
+  // Modern volume properties check
+  DWORD volumeFlags = 0;
+  wchar_t fileSystemName[MAX_PATH + 1] = {0};
+
+  if (GetVolumeInformationW(drive.c_str(), nullptr, 0, nullptr, nullptr,
+                            &volumeFlags, fileSystemName, MAX_PATH)) {
+
+    // Check for modern system volume indicators
+    if ((volumeFlags & FILE_SUPPORTS_SYSTEM_PATHS) ||
+        (volumeFlags & FILE_SUPPORTS_SYSTEM_FILES)) {
+      DEBUG_LOG("[IsSystemVolume] %ls has system volume flags (0x%08X)",
+                drive.c_str(), volumeFlags);
+      return true;
+    }
+  } else {
+    DEBUG_LOG("[IsSystemVolume] %ls GetVolumeInformationW failed: %lu",
+              drive.c_str(), GetLastError());
+  }
+
+  DEBUG_LOG("[IsSystemVolume] %ls is not a system volume", drive.c_str());
+  return false;
+}
+
+// Legacy compatibility overload
+inline bool IsSystemVolume(const WCHAR *drive) {
+  return IsSystemVolume(std::wstring(drive));
+}
+
+} // namespace FSMeta