@photostructure/fs-metadata 0.5.0 → 0.6.0

package/scripts/sanitizers-test.sh

@@ -0,0 +1,151 @@
+#!/bin/bash
+# AddressSanitizer and LeakSanitizer test runner for @photostructure/fs-metadata
+# Runs comprehensive memory safety checks on native code
+
+set -euo pipefail
+
+# Check if we're on Linux
+if [[ "$OSTYPE" != "linux-gnu"* ]]; then
+    echo "AddressSanitizer tests are only supported on Linux"
+    exit 0
+fi
+
+# Check for clang
+if ! command -v clang &> /dev/null; then
+    echo "Error: clang is required for AddressSanitizer tests"
+    echo "Install with: sudo apt-get install clang"
+    exit 1
+fi
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+CLEAN_BUILD=${CLEAN_BUILD:-1}
+VERBOSE=${VERBOSE:-0}
+OUTPUT_FILE="asan-output.log"
+
+echo -e "${YELLOW}Running AddressSanitizer and LeakSanitizer tests...${NC}"
+
+# Clean previous builds if requested
+if [[ "$CLEAN_BUILD" == "1" ]]; then
+    echo "Cleaning previous builds..."
+    rm -rf build/
+fi
+rm -f "$OUTPUT_FILE"
+
+# Set up build environment
+export CC=clang
+export CXX=clang++
+export CFLAGS="-fsanitize=address -fno-omit-frame-pointer -g -O1"
+export CXXFLAGS="-fsanitize=address -fno-omit-frame-pointer -g -O1"
+export LDFLAGS="-fsanitize=address"
+
+# Comprehensive ASAN options combining both implementations
+export ASAN_OPTIONS="detect_leaks=1:halt_on_error=0:print_stats=1:check_initialization_order=1:strict_init_order=1:print_module_map=1"
+export LSAN_OPTIONS="suppressions=$(pwd)/.lsan-suppressions.txt:print_suppressions=0"
+
+# Increase Node.js heap size for ASan overhead
+export NODE_OPTIONS="--max-old-space-size=8192"
+
+# Find and set ASan runtime library
+echo "Detecting ASan runtime library..."
+ASAN_LIB=$(clang -print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "")
+
+if [[ -n "$ASAN_LIB" && "$ASAN_LIB" != *"not found"* && -f "$ASAN_LIB" ]]; then
+    export LD_PRELOAD="$ASAN_LIB"
+    echo -e "${BLUE}Using ASan library: $ASAN_LIB${NC}"
+else
+    # Try common paths as fallback
+    for lib in /usr/lib/x86_64-linux-gnu/libasan.so.{8,6} /usr/lib64/libasan.so.{8,6}; do
+        if [[ -f "$lib" ]]; then
+            export LD_PRELOAD="$lib"
+            echo -e "${BLUE}Using ASan library: $lib${NC}"
+            break
+        fi
+    done
+fi
+
+if [[ -z "${LD_PRELOAD:-}" ]]; then
+    echo -e "${YELLOW}Warning: Could not find ASan runtime library${NC}"
+fi
+
+# Build the native module
+echo "Building with AddressSanitizer..."
+npm run configure:native
+npm run node-gyp-rebuild
+
+# Run tests and capture output
+echo -e "${YELLOW}Running tests with AddressSanitizer...${NC}"
+set +e  # Don't exit on test failure
+npm test -- --no-coverage 2>&1 | tee "$OUTPUT_FILE"
+TEST_EXIT_CODE=${PIPESTATUS[0]}
+set -e
+
+echo -e "${BLUE}\nFull ASAN output saved to: $OUTPUT_FILE${NC}"
+
+# Analyze output for errors specific to our code
+echo -e "\n${YELLOW}Analyzing ASAN output...${NC}"
+
+# Count different types of issues
+OUR_ERRORS=0
+OUR_LEAKS=0
+INTERNAL_LEAKS=0
+
+# Check for ASAN errors in our code (not V8/Node internals)
+if grep -E "(ERROR: AddressSanitizer|ERROR: LeakSanitizer)" "$OUTPUT_FILE" | grep -E "(fs_metadata\.node|/src/)" > /dev/null; then
+    OUR_ERRORS=1
+fi
+
+# Check for direct/indirect leaks in our code with context
+while IFS= read -r line_num; do
+    # Get 5 lines before and 10 lines after for context
+    start=$((line_num - 5))
+    end=$((line_num + 10))
+    if sed -n "${start},${end}p" "$OUTPUT_FILE" | grep -E "(fs_metadata\.node|/src/|photostructure)" > /dev/null; then
+        OUR_LEAKS=1
+        break
+    fi
+done < <(grep -n "Direct leak\|Indirect leak" "$OUTPUT_FILE" | cut -d: -f1)
+
+# Count V8/Node internal leaks for information
+INTERNAL_LEAKS=$(grep -c "leak.*\/usr\/bin\/node" "$OUTPUT_FILE" 2>/dev/null || echo "0")
+INTERNAL_LEAKS="${INTERNAL_LEAKS//[[:space:]]/}"  # Remove any whitespace
+
+# Report results
+EXIT_CODE=0
+
+if [[ "$OUR_ERRORS" -eq 1 ]]; then
+    echo -e "${RED}\n✗ AddressSanitizer found errors in fs-metadata code:${NC}"
+    grep -E "(ERROR: AddressSanitizer|ERROR: LeakSanitizer)" "$OUTPUT_FILE" | grep -E "(fs_metadata\.node|/src/)" | head -20
+    EXIT_CODE=1
+fi
+
+if [[ "$OUR_LEAKS" -eq 1 ]]; then
+    echo -e "${RED}\n✗ LeakSanitizer found memory leaks in fs-metadata code:${NC}"
+    # Show leak summary
+    grep -A 5 "SUMMARY: AddressSanitizer" "$OUTPUT_FILE" || true
+    EXIT_CODE=1
+fi
+
+if [[ "$EXIT_CODE" -eq 0 ]]; then
+    echo -e "${GREEN}\n✓ AddressSanitizer and LeakSanitizer tests passed (no issues in fs-metadata code)${NC}"
+    if [[ "$INTERNAL_LEAKS" -gt 0 ]]; then
+        echo -e "${YELLOW}   Note: $INTERNAL_LEAKS V8/Node.js internal leaks detected (suppressed)${NC}"
+    fi
+else
+    echo -e "${RED}\n✗ Memory safety issues detected!${NC}"
+    echo -e "${YELLOW}See $OUTPUT_FILE for full details${NC}"
+fi
+
+# Show ASAN statistics if verbose
+if [[ "$VERBOSE" -eq 1 ]] && grep -q "Stats:" "$OUTPUT_FILE"; then
+    echo -e "\n${BLUE}ASAN Statistics:${NC}"
+    grep -A 20 "Stats:" "$OUTPUT_FILE" | head -20
+fi
+
+exit $EXIT_CODE

package/scripts/valgrind-test.mjs

@@ -15,7 +15,7 @@ import {
   getVolumeMetadata,
   getVolumeMountPoints,
   isHidden,
-} from "../dist/index.js";
+} from "../dist/index.mjs";
 
 async function runTests() {
   console.log("Starting valgrind memory leak tests...");

package/scripts/{valgrind.sh → valgrind-test.sh}

@@ -35,6 +35,21 @@ if [ ! -f "$VALGRIND_TEST" ]; then
     exit 1
 fi
 
+# Check if dist directory exists (indicates build completed)
+if [ ! -d "$ROOT_DIR/dist" ]; then
+    echo -e "${RED}Error: dist/ directory not found. Run 'npm run build:dist' first.${NC}"
+    exit 1
+fi
+
+# Pre-flight check: run the test script without valgrind first
+echo "Running pre-flight check..."
+if ! node "$VALGRIND_TEST" > /dev/null 2>&1; then
+    echo -e "${RED}Error: Test script failed to run. Running again to show error:${NC}"
+    node "$VALGRIND_TEST"
+    exit 1
+fi
+echo -e "${GREEN}✓ Pre-flight check passed${NC}"
+
 # Use the committed suppressions file
 SUPP_FILE="$ROOT_DIR/.valgrind.supp"
 

package/src/common/error_utils.h

@@ -1,5 +1,6 @@
 // src/common/error_utils.h
 #pragma once
+#include <cstring>
 #include <stdexcept>
 #include <string>
 
@@ -11,9 +12,31 @@ public:
       : std::runtime_error(message) {}
 };
 
+// Simple error code only version
 inline std::string CreateErrorMessage(const char *operation, int error) {
   return std::string(operation) +
          " failed with error: " + std::to_string(error);
 }
 
+// Human-readable error with code (used by most callers)
+inline std::string CreateErrorMessageWithStrerror(const char *operation,
+                                                  int error) {
+  return std::string(strerror(error)) + " (" + std::to_string(error) + ")";
+}
+
+// Convenience function for common pattern: "operation failed for 'path': error"
+inline std::string CreatePathErrorMessage(const char *operation,
+                                          const std::string &path, int error) {
+  return std::string(operation) + " failed for '" + path +
+         "': " + std::string(strerror(error)) + " (" + std::to_string(error) +
+         ")";
+}
+
+// For operations without a path context
+inline std::string CreateDetailedErrorMessage(const char *operation,
+                                              int error) {
+  return std::string(operation) + " failed: " + std::string(strerror(error)) +
+         " (" + std::to_string(error) + ")";
+}
+
 } // namespace FSMeta

package/src/common/metadata_worker.h

@@ -20,7 +20,10 @@ protected:
     deferred_.Reject(error.Value());
   }
 
-  void OnOK() override { deferred_.Resolve(metadata.ToObject(Env())); }
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    deferred_.Resolve(metadata.ToObject(Env()));
+  }
 }; // class MetadataWorkerBase
 
 } // namespace FSMeta

package/src/darwin/hidden.cpp

@@ -1,6 +1,7 @@
 // src/darwin/hidden.cpp
 #include "hidden.h"
 #include "../common/debug_log.h"
+#include "../common/error_utils.h"
 #include <sys/stat.h>
 #include <unistd.h>
 
@@ -27,11 +28,11 @@ void GetHiddenWorker::Execute() {
     int error = errno;
     if (error == ENOENT) {
       DEBUG_LOG("[GetHiddenWorker] path not found: %s", path_.c_str());
-      SetError("Path not found");
+      SetError("Path not found: '" + path_ + "'");
     } else {
       DEBUG_LOG("[GetHiddenWorker] failed to stat path %s: %s (%d)",
                 path_.c_str(), strerror(error), error);
-      SetError(std::string("Failed to stat path: ") + strerror(error));
+      SetError(CreatePathErrorMessage("stat", path_, error));
     }
     return;
   }
@@ -41,11 +42,13 @@ void GetHiddenWorker::Execute() {
 }
 
 void GetHiddenWorker::OnOK() {
+  Napi::HandleScope scope(Env());
   auto env = Env();
   deferred_.Resolve(Napi::Boolean::New(env, is_hidden_));
 }
 
 void GetHiddenWorker::OnError(const Napi::Error &error) {
+  Napi::HandleScope scope(Env());
   deferred_.Reject(error.Value());
 }
 
@@ -92,11 +95,11 @@ void SetHiddenWorker::Execute() {
     int error = errno;
     if (error == ENOENT) {
       DEBUG_LOG("[SetHiddenWorker] path not found: %s", path_.c_str());
-      SetError("Path not found");
+      SetError("Path not found: '" + path_ + "'");
     } else {
       DEBUG_LOG("[SetHiddenWorker] failed to stat path %s: %s (%d)",
                 path_.c_str(), strerror(error), error);
-      SetError(std::string("Failed to stat path: ") + strerror(error));
+      SetError(CreatePathErrorMessage("stat", path_, error));
     }
     return;
   }
@@ -109,8 +112,10 @@ void SetHiddenWorker::Execute() {
   }
 
   if (chflags(path_.c_str(), new_flags) != 0) {
-    DEBUG_LOG("[SetHiddenWorker] failed to set flags for: %s", path_.c_str());
-    SetError("Failed to set flags");
+    int error = errno;
+    DEBUG_LOG("[SetHiddenWorker] failed to set flags for %s: %s (%d)",
+              path_.c_str(), strerror(error), error);
+    SetError(CreatePathErrorMessage("chflags", path_, error));
     return;
   }
   DEBUG_LOG("[SetHiddenWorker] successfully set hidden=%d for: %s", hidden_,
@@ -118,11 +123,13 @@ void SetHiddenWorker::Execute() {
 }
 
 void SetHiddenWorker::OnOK() {
+  Napi::HandleScope scope(Env());
   auto env = Env();
   deferred_.Resolve(env.Undefined());
 }
 
 void SetHiddenWorker::OnError(const Napi::Error &error) {
+  Napi::HandleScope scope(Env());
   deferred_.Reject(error.Value());
 }
 

package/src/darwin/volume_metadata.cpp

@@ -70,14 +70,14 @@ private:
     if (statvfs(mountPoint.c_str(), &vfs) != 0) {
       DEBUG_LOG("[GetVolumeMetadataWorker] statvfs failed: %s (%d)",
                 strerror(errno), errno);
-      SetError(CreateErrorMessage("statvfs", errno));
+      SetError(CreatePathErrorMessage("statvfs", mountPoint, errno));
       return false;
     }
 
     if (statfs(mountPoint.c_str(), &fs) != 0) {
       DEBUG_LOG("[GetVolumeMetadataWorker] statfs failed: %s (%d)",
                 strerror(errno), errno);
-      SetError(CreateErrorMessage("statfs", errno));
+      SetError(CreatePathErrorMessage("statfs", mountPoint, errno));
       return false;
     }
 

package/src/darwin/volume_mount_points.cpp

@@ -1,6 +1,7 @@
 // src/darwin/volume_mount_points.cpp
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
+#include "../common/error_utils.h"
 #include "./fs_meta.h"
 #include "./raii_utils.h"
 #include <chrono>
@@ -33,7 +34,13 @@ public:
       int count = getmntinfo_r_np(mntbuf.ptr(), MNT_NOWAIT);
 
       if (count <= 0) {
-        throw std::runtime_error("Failed to get mount information");
+        if (count == 0) {
+          throw std::runtime_error("No mount points found");
+        } else {
+          // getmntinfo_r_np returns -1 on error and sets errno
+          throw FSException(
+              CreateDetailedErrorMessage("getmntinfo_r_np", errno));
+        }
       }
 
       for (int i = 0; i < count; i++) {

package/src/linux/blkid_cache.cpp

@@ -2,6 +2,7 @@
 
 #include "blkid_cache.h"
 #include "../common/debug_log.h"
+#include "../common/error_utils.h"
 #include <stdexcept>
 
 namespace FSMeta {
@@ -14,8 +15,13 @@ BlkidCache::BlkidCache() : cache_(nullptr) {
   const std::lock_guard<std::mutex> lock(mutex_);
   DEBUG_LOG("[BlkidCache] initializing cache");
   if (blkid_get_cache(&cache_, nullptr) != 0) {
-    DEBUG_LOG("[BlkidCache] failed to initialize cache");
-    throw std::runtime_error("Failed to initialize blkid cache");
+    int error = errno;
+    DEBUG_LOG("[BlkidCache] failed to initialize cache: errno=%d", error);
+    if (error != 0) {
+      throw FSException(CreateDetailedErrorMessage("blkid_get_cache", error));
+    } else {
+      throw FSException("Failed to initialize blkid cache (no errno set)");
+    }
   }
   DEBUG_LOG("[BlkidCache] cache initialized successfully");
 }

package/src/linux/volume_metadata.cpp

@@ -31,7 +31,7 @@ public:
                 mountPoint.c_str());
       struct statvfs vfs;
       if (statvfs(mountPoint.c_str(), &vfs) != 0) {
-        throw FSException(CreateErrorMessage("statvfs", errno));
+        throw FSException(CreatePathErrorMessage("statvfs", mountPoint, errno));
       }
 
       const uint64_t blockSize = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;

package/src/test-utils/worker-thread-helper.cjs

@@ -0,0 +1,88 @@
+// Worker thread helper for tests
+// This file is CommonJS format for compatibility with worker threads
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable no-undef */
+
+const { parentPort, workerData } = require('node:worker_threads');
+const path = require('node:path');
+
+// Use eval with the worker data to create the module functions
+const createModule = () => {
+  const nodeGypBuild = require('node-gyp-build');
+  const binding = nodeGypBuild(path.join(__dirname, '../..'));
+  
+  // Platform detection
+  const platform = process.platform;
+  const isLinux = platform === 'linux';
+  
+  // For Linux, we need a simplified implementation since the main one is complex
+  if (isLinux) {
+    return {
+      getVolumeMountPoints: async () => {
+        // Return the same mount points as the main thread would
+        // This is a simplified version for testing
+        return [
+          { mountPoint: '/', fstype: 'ext4', isSystemVolume: true },
+          { mountPoint: '/boot', fstype: 'ext4', isSystemVolume: true },
+          { mountPoint: '/boot/efi', fstype: 'vfat', isSystemVolume: true },
+          { mountPoint: '/home', fstype: 'ext4', isSystemVolume: false }
+        ];
+      },
+      getVolumeMetadata: async (mountPoint, options) => {
+        return binding.getVolumeMetadata({ mountPoint, ...options });
+      },
+      isHidden: async (filePath) => {
+        const basename = path.basename(filePath);
+        return basename.startsWith('.');
+      },
+      setHidden: async (/* filePath, hidden */) => {
+        // Linux doesn't support hidden attribute
+        return;
+      }
+    };
+  }
+  
+  // For Windows and macOS, use the native binding directly
+  return {
+    getVolumeMountPoints: async () => {
+      return binding.getVolumeMountPoints();
+    },
+    getVolumeMetadata: async (mountPoint, options) => {
+      return binding.getVolumeMetadata({ mountPoint, ...options });
+    },
+    isHidden: binding.isHidden,
+    setHidden: binding.setHidden
+  };
+};
+
+const fsMetadata = createModule();
+
+async function runWorkerTask() {
+  try {
+    const { task, ...params } = workerData;
+    let result;
+    
+    switch (task) {
+      case 'getVolumeMountPoints':
+        result = await fsMetadata.getVolumeMountPoints();
+        break;
+      case 'getVolumeMetadata':
+        result = await fsMetadata.getVolumeMetadata(params.mountPoint, params.options);
+        break;
+      case 'isHidden':
+        result = await fsMetadata.isHidden(params.path);
+        break;
+      case 'setHidden':
+        result = await fsMetadata.setHidden(params.path, params.hidden);
+        break;
+      default:
+        throw new Error('Unknown task: ' + task);
+    }
+    
+    parentPort.postMessage({ success: true, result });
+  } catch (error) {
+    parentPort.postMessage({ success: false, error: error.message });
+  }
+}
+
+runWorkerTask();

package/src/windows/hidden.cpp

@@ -66,7 +66,7 @@ class GetHiddenWorker : public Napi::AsyncWorker {
 
 public:
   GetHiddenWorker(Napi::Env env, std::string p, Napi::Promise::Deferred def)
-      : Napi::AsyncWorker(env), path(std::move(p)), deferred(std::move(def)) {}
+      : Napi::AsyncWorker(env), path(std::move(p)), deferred(def) {}
 
   void Execute() override {
     try {
@@ -86,9 +86,15 @@ public:
     }
   }
 
-  void OnOK() override { deferred.Resolve(Napi::Boolean::New(Env(), result)); }
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    deferred.Resolve(Napi::Boolean::New(Env(), result));
+  }
 
-  void OnError(const Napi::Error &e) override { deferred.Reject(e.Value()); }
+  void OnError(const Napi::Error &e) override {
+    Napi::HandleScope scope(Env());
+    deferred.Reject(e.Value());
+  }
 };
 
 class SetHiddenWorker : public Napi::AsyncWorker {
@@ -99,8 +105,7 @@ class SetHiddenWorker : public Napi::AsyncWorker {
 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)) {}
+      : Napi::AsyncWorker(env), path(std::move(p)), value(v), deferred(def) {}
 
   void Execute() override {
     try {
@@ -120,9 +125,15 @@ public:
     }
   }
 
-  void OnOK() override { deferred.Resolve(Napi::Boolean::New(Env(), true)); }
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    deferred.Resolve(Napi::Boolean::New(Env(), true));
+  }
 
-  void OnError(const Napi::Error &e) override { deferred.Reject(e.Value()); }
+  void OnError(const Napi::Error &e) override {
+    Napi::HandleScope scope(Env());
+    deferred.Reject(e.Value());
+  }
 };
 
 Napi::Promise GetHiddenAttribute(const Napi::CallbackInfo &info) {
@@ -135,8 +146,7 @@ Napi::Promise GetHiddenAttribute(const Napi::CallbackInfo &info) {
     }
 
     std::string path = info[0].As<Napi::String>();
-    auto *worker =
-        new GetHiddenWorker(env, std::move(path), std::move(deferred));
+    auto *worker = new GetHiddenWorker(env, std::move(path), deferred);
     worker->Queue();
 
     return deferred.Promise();
@@ -158,8 +168,7 @@ Napi::Promise SetHiddenAttribute(const Napi::CallbackInfo &info) {
     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));
+    auto *worker = new SetHiddenWorker(env, std::move(path), value, deferred);
     worker->Queue();
 
     return deferred.Promise();