@photostructure/fs-metadata 0.6.0 → 0.7.0

package/scripts/install.cjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+/**
+ * Custom install script that handles Windows architecture defines
+ * when node-gyp-build needs to compile from source
+ */
+
+const { spawn } = require("child_process");
+const { platform, arch } = require("os");
+
+// If in CI and on Windows, set architecture defines
+if (process.env.CI && platform() === "win32") {
+  const currentArch = arch();
+
+  // Set architecture-specific defines for Windows
+  if (currentArch === "x64") {
+    process.env.CL = "/D_M_X64 /D_WIN64 /D_AMD64_";
+  } else if (currentArch === "arm64") {
+    process.env.CL = "/D_M_ARM64 /D_WIN64";
+  }
+
+  console.log(`Windows CI detected: arch=${currentArch}, CL=${process.env.CL}`);
+}
+
+// Run node-gyp-build
+const child = spawn("npx", ["node-gyp-build"], {
+  stdio: "inherit",
+  shell: true,
+  env: process.env,
+});
+
+child.on("error", (error) => {
+  console.error("Failed to run node-gyp-build:", error);
+  process.exit(1);
+});
+
+child.on("exit", (code) => {
+  if (code !== 0) {
+    console.error(`node-gyp-build exited with code ${code}`);
+    process.exit(code || 1);
+  }
+});

package/scripts/is-platform.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { platform } from "os";
+import { platform } from "node:os";
 
 const targetPlatform = process.argv[2];
 if (!targetPlatform) {

package/scripts/macos-asan.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+# macOS AddressSanitizer test script
+
+set -euo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${YELLOW}=== macOS AddressSanitizer Memory Test ===${NC}"
+
+# Check if we're on macOS
+if [[ "$(uname)" != "Darwin" ]]; then
+    echo -e "${YELLOW}Not on macOS. Skipping macOS-specific memory tests.${NC}"
+    exit 0
+fi
+
+# Clean and rebuild with AddressSanitizer
+echo -e "${YELLOW}Cleaning previous builds...${NC}"
+npm run clean:native
+
+# Configure build with ASan flags
+echo -e "${YELLOW}Building with AddressSanitizer enabled...${NC}"
+export CFLAGS="-fsanitize=address -g -O1 -fno-omit-frame-pointer"
+export CXXFLAGS="-fsanitize=address -g -O1 -fno-omit-frame-pointer"
+export LDFLAGS="-fsanitize=address"
+
+# Set ASan options
+export ASAN_OPTIONS="detect_leaks=1:check_initialization_order=1:strict_init_order=1:print_stats=1:halt_on_error=0"
+export MallocScribble=1
+export MallocGuardEdges=1
+
+# Find and set the ASan library path for macOS
+# First try to find the most recent version
+ASAN_LIB=$(find /Library/Developer/CommandLineTools/usr/lib/clang/*/lib/darwin -name "libclang_rt.asan_osx_dynamic.dylib" 2>/dev/null | sort -V | tail -1)
+if [[ -z "$ASAN_LIB" ]]; then
+    # Try alternative location
+    ASAN_LIB=$(find /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/*/lib/darwin -name "libclang_rt.asan_osx_dynamic.dylib" 2>/dev/null | sort -V | tail -1)
+fi
+
+if [[ -n "$ASAN_LIB" ]]; then
+    export DYLD_INSERT_LIBRARIES="$ASAN_LIB"
+    echo -e "${GREEN}Using ASan library: $ASAN_LIB${NC}"
+else
+    echo -e "${RED}Warning: Could not find ASan library. Tests may not run properly.${NC}"
+fi
+
+# Build the native module
+npm run node-gyp-rebuild
+
+# Run tests with ASan
+echo -e "${YELLOW}Running tests with AddressSanitizer...${NC}"
+
+# Note: On macOS with SIP enabled, DYLD_INSERT_LIBRARIES is stripped from
+# child processes. Jest uses worker processes, so we need to run tests
+# in a single process to ensure ASAN works correctly.
+
+# Run the test and capture output
+TEST_OUTPUT=$(npm test -- --runInBand 2>&1)
+TEST_EXIT_CODE=$?
+
+if [[ $TEST_EXIT_CODE -eq 0 ]]; then
+    echo -e "${GREEN}✓ Tests passed with AddressSanitizer${NC}"
+else
+    # Check if the failure is due to SIP interceptor issues
+    if echo "$TEST_OUTPUT" | grep -q "interceptors not installed"; then
+        echo -e "${YELLOW}⚠ Tests completed but AddressSanitizer interceptors not installed${NC}"
+        echo -e "${YELLOW}  This is due to macOS System Integrity Protection (SIP) stripping${NC}"
+        echo -e "${YELLOW}  DYLD_INSERT_LIBRARIES from child processes. This is expected behavior.${NC}"
+        echo -e "${YELLOW}  To run ASAN tests properly, you may need to disable SIP temporarily.${NC}"
+        # Don't treat this as a failure
+    else
+        echo -e "${RED}✗ Tests failed with AddressSanitizer${NC}"
+        echo "$TEST_OUTPUT"
+        # This is a real failure, exit with error
+        exit 1
+    fi
+fi
+
+# Run memory leak check using leaks tool
+echo -e "${YELLOW}Running macOS leaks tool...${NC}"
+if command -v leaks >/dev/null 2>&1; then
+    # Get the project root directory
+    PROJECT_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+    
+    # Check if the native module exists
+    if [ ! -f "${PROJECT_ROOT}/build/Release/fs_metadata.node" ]; then
+        echo -e "${RED}Native module not found. Skipping leaks test.${NC}"
+        exit 1
+    fi
+    
+    # Create a simple test script
+    cat > /tmp/test-leaks.js << EOF
+const fs = require('fs');
+const binding = require('${PROJECT_ROOT}/build/Release/fs_metadata.node');
+
+async function testVolumeMountPoints() {
+    for (let i = 0; i < 100; i++) {
+        await binding.getVolumeMountPoints();
+    }
+}
+
+async function testVolumeMetadata() {
+    const mountPoints = await binding.getVolumeMountPoints();
+    if (mountPoints.length > 0) {
+        for (let i = 0; i < 10; i++) {
+            await binding.getVolumeMetadata({ mountPoint: mountPoints[0].mountPoint });
+        }
+    }
+}
+
+async function runTests() {
+    await testVolumeMountPoints();
+    await testVolumeMetadata();
+    
+    // Force garbage collection if available
+    if (global.gc) {
+        global.gc();
+    }
+}
+
+runTests().then(() => {
+    console.log('Tests completed');
+    // Give time for cleanup
+    setTimeout(() => process.exit(0), 1000);
+}).catch(err => {
+    console.error('Test failed:', err);
+    process.exit(1);
+});
+EOF
+
+    # Run with leaks detection
+    echo -e "${YELLOW}Executing memory leak test...${NC}"
+    if leaks --atExit -- node --expose-gc /tmp/test-leaks.js > /tmp/leaks-output.txt 2>&1; then
+        echo -e "${GREEN}✓ No memory leaks detected${NC}"
+        # Show summary if available
+        if grep -q "Process" /tmp/leaks-output.txt; then
+            echo -e "${YELLOW}Summary:${NC}"
+            grep -E "(Process|leaks for|total leaked bytes)" /tmp/leaks-output.txt || true
+        fi
+    else
+        echo -e "${RED}✗ Memory leaks detected or leaks tool failed:${NC}"
+        cat /tmp/leaks-output.txt
+        # Don't exit with failure - leaks tool can have false positives
+        echo -e "${YELLOW}Note: The leaks tool may report false positives from Node.js internals.${NC}"
+    fi
+    
+    rm -f /tmp/test-leaks.js /tmp/leaks-output.txt
+else
+    echo -e "${YELLOW}leaks tool not available. Skipping native leak detection.${NC}"
+fi
+
+echo -e "${GREEN}=== All macOS memory tests passed! ===${NC}"

package/scripts/post-build.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import { copyFile } from "fs/promises";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+import { copyFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const distDir = join(__dirname, "..", "dist");

package/scripts/prebuild-linux-glibc.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+# Build native module with portable GLIBC compatibility
+# Uses Debian 11 Bullseye (GLIBC 2.31) to balance compatibility and modern toolchain
+#
+# GLIBC versions in official Node.js Docker images:
+# - node:*-buster:   GLIBC 2.28 (Debian 10) - Python 3.7, GCC 8.3 (too old)
+# - node:*-bullseye: GLIBC 2.31 (Debian 11) - Python 3.9, GCC 10.2 (good balance)
+# - node:*-bookworm: GLIBC 2.36 (Debian 12) - Python 3.11, GCC 12.2
+# - node:* (default): GLIBC 2.36 (Debian 12 Bookworm)
+# - node:*-alpine:   musl libc (not GLIBC)
+#
+# Other common environments:
+# - Ubuntu 20.04 LTS: GLIBC 2.31 (matches our target)
+# - Ubuntu 22.04 LTS: GLIBC 2.35
+# - CentOS 7:         GLIBC 2.17 (EOL, not supported)
+# - Amazon Linux 2:   GLIBC 2.26 (older, but should work)
+#
+# By targeting GLIBC 2.31, we support Ubuntu 20.04 LTS and newer,
+# while having a modern enough toolchain for Node.js requirements.
+
+set -euo pipefail
+
+# Allow architecture override (for CI cross-compilation)
+TARGET_ARCH="${TARGET_ARCH:-}"
+
+# If no target architecture specified, detect from host
+if [ -z "$TARGET_ARCH" ]; then
+  ARCH=$(uname -m)
+  if [ "$ARCH" = "x86_64" ]; then
+    TARGET_ARCH="x64"
+  elif [ "$ARCH" = "aarch64" ]; then
+    TARGET_ARCH="arm64"
+  else
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+  fi
+fi
+
+# Map to Docker platform architecture
+if [ "$TARGET_ARCH" = "x64" ]; then
+  DOCKER_ARCH="amd64"
+elif [ "$TARGET_ARCH" = "arm64" ]; then
+  DOCKER_ARCH="arm64"
+else
+  echo "Unsupported target architecture: $TARGET_ARCH"
+  exit 1
+fi
+
+# Determine which build command to use
+BUILD_CMD="${BUILD_CMD:-npm run build:native}"
+
+# Check if we're already in a compatible environment
+if [ -f /etc/os-release ]; then
+  . /etc/os-release
+  if [[ "${ID:-}" == "debian" && "${VERSION_ID:-}" == "11" ]]; then
+    echo "Already in Debian 11 Bullseye, building directly..."
+    $BUILD_CMD
+    exit 0
+  fi
+fi
+
+# Check if Docker is available
+if ! command -v docker &> /dev/null; then
+  echo "Docker not found, falling back to local build"
+  echo "Warning: Binary may not be portable due to GLIBC version"
+  $BUILD_CMD
+  exit 0
+fi
+
+echo "Building native module in Debian 11 Bullseye container for GLIBC 2.31 compatibility..."
+echo "Target architecture: $TARGET_ARCH (Docker platform: linux/$DOCKER_ARCH)"
+
+# Create a container, build inside it, then copy artifacts out
+CONTAINER_NAME="fs-metadata-build-$$"
+
+# Start container in background
+docker run -d \
+  --name "$CONTAINER_NAME" \
+  --platform "linux/$DOCKER_ARCH" \
+  node:20-bullseye \
+  sleep 3600
+
+# Copy project files into container
+docker cp . "$CONTAINER_NAME:/tmp/project"
+
+# Run build inside container
+# Debian 11 has Python 3.9 and GCC 10.2 which support our requirements
+docker exec "$CONTAINER_NAME" sh -c "
+  cd /tmp/project && \
+  apt-get update -qq && \
+  apt-get install -y -qq build-essential python3 libglib2.0-dev libblkid-dev uuid-dev git && \
+  # Verify versions
+  echo 'Python version:' && python3 --version && \
+  echo 'GCC version:' && gcc --version | head -1 && \
+  # Build the project
+  npm ci --ignore-scripts && \
+  $BUILD_CMD
+"
+
+# Copy artifacts back
+docker cp "$CONTAINER_NAME:/tmp/project/prebuilds" . 2>/dev/null || true
+docker cp "$CONTAINER_NAME:/tmp/project/build" . 2>/dev/null || true
+docker cp "$CONTAINER_NAME:/tmp/project/config.gypi" . 2>/dev/null || true
+
+# Fix ownership (docker cp preserves container's root ownership)
+if [ -d prebuilds ]; then
+  chown -R "$(id -u):$(id -g)" prebuilds
+fi
+if [ -d build ]; then
+  chown -R "$(id -u):$(id -g)" build
+fi
+if [ -f config.gypi ]; then
+  chown "$(id -u):$(id -g)" config.gypi
+fi
+
+# Clean up container
+docker rm -f "$CONTAINER_NAME" >/dev/null
+
+echo "Portable build complete!"

package/scripts/prebuildify-wrapper.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env tsx
+
+import { spawn } from "node:child_process";
+import { arch, platform } from "node:os";
+
+/**
+ * Wrapper for prebuildify to ensure architecture is explicitly passed This
+ * works around the issue where prebuildify doesn't properly evaluate
+ * binding.gyp conditions for Windows architecture defines
+ *
+ * NOTE: if you don't include <windows.h> in your binding.gyp, this script is
+ * unnecessary.
+ */
+
+// Get the current architecture and platform
+const currentArch = arch(); // 'x64', 'arm64', etc.
+const currentPlatform = platform(); // 'win32', 'darwin', 'linux'
+
+console.log(`Building for platform: ${currentPlatform}, arch: ${currentArch}`);
+
+// Set up environment variables to help node-gyp
+const env = { ...process.env };
+
+// Set architecture-specific defines for Windows
+if (currentPlatform === "win32") {
+  // Try various environment variables that might work
+  env.npm_config_arch = currentArch;
+  env.npm_config_target_arch = currentArch;
+  env.PREBUILD_ARCH = currentArch;
+
+  // Try setting compiler flags directly
+  if (currentArch === "x64") {
+    env.CL = "/D_M_X64 /D_WIN64 /D_AMD64_";
+  } else if (currentArch === "arm64") {
+    env.CL = "/D_M_ARM64 /D_WIN64";
+  }
+}
+
+// Build the prebuildify command with explicit architecture
+const args = [
+  "--napi",
+  "--tag-libc",
+  "--strip",
+  "--arch",
+  currentArch,
+  "--platform",
+  currentPlatform,
+];
+
+// Add any additional arguments passed to this script
+if (process.argv.length > 2) {
+  args.push(...process.argv.slice(2));
+}
+
+console.log(`Running: prebuildify ${args.join(" ")}`);
+if (currentPlatform === "win32" && env.CL) {
+  console.log(`CL environment variable: ${env.CL}`);
+}
+
+// Spawn prebuildify with the arguments
+const child = spawn("prebuildify", args, {
+  stdio: "inherit",
+  shell: true,
+  env,
+});
+
+child.on("error", (error) => {
+  console.error("Failed to start prebuildify:", error);
+  process.exit(1);
+});
+
+child.on("exit", (code) => {
+  if (code !== 0) {
+    console.error(`prebuildify exited with code ${code}`);
+    process.exit(code || 1);
+  }
+});

package/scripts/precommit.ts

@@ -0,0 +1,70 @@
+import { execSync } from "node:child_process";
+import { rmSync } from "node:fs";
+import { platform } from "node:os";
+import { exit } from "node:process";
+
+const isLinux = platform() === "linux";
+const isMacOS = platform() === "darwin";
+
+function run({
+  cmd,
+  desc,
+  exitOnFail: shouldExit = true,
+}: {
+  cmd: string;
+  desc: string;
+  exitOnFail?: boolean;
+}) {
+  console.log(`\n▶ ${desc ?? cmd}`);
+  try {
+    execSync(cmd, { stdio: "inherit" });
+  } catch (error) {
+    console.error(`✗ Failed: ${desc ?? cmd}: ` + error);
+    if (shouldExit) exit(1);
+  }
+}
+
+run({ cmd: "npm install", desc: "Installing dependencies" });
+run({ cmd: "npm run update", desc: "Updating dependencies" });
+rmSync("package-lock.json", { force: true });
+run({ cmd: "npm install", desc: "Updating dependencies" });
+run({ cmd: "npm run clean", desc: "Start fresh" });
+run({ cmd: "npm run fmt", desc: "Formatting code" });
+run({ cmd: "npm run lint", desc: "Running linting checks" });
+run({ cmd: "npm run docs", desc: "TypeDoc generation" });
+run({ cmd: "npm run build:dist", desc: "Building distribution files" });
+
+// Detect if we're using glibc (vs musl)
+// Check process.report for musl loader - if not found, assume glibc
+const isGlibc = (() => {
+  if (!isLinux) return false;
+  const report = process.report?.getReport() as any;
+  return !report?.sharedObjects?.some((lib: string) => /ld-musl/.test(lib));
+})();
+
+// Build native module with portable GLIBC
+if (isLinux && isGlibc) {
+  run({
+    cmd: "npm run build:linux-glibc",
+    desc: "Building native project with portable GLIBC",
+  });
+} else {
+  // Clean old native builds to ensure fresh compilation
+  run({ cmd: "npm run clean:native", desc: "Cleaning old native builds" });
+  run({ cmd: "npm run build:native", desc: "Building native module" });
+}
+
+run({ cmd: "npm run tests", desc: "Running tests in ESM & CJS mode" });
+
+// Platform-specific checks
+if (isLinux || isMacOS) {
+  // Remove stale compile_commands.json to ensure it's regenerated with current settings
+  rmSync("compile_commands.json", { force: true });
+  run({ cmd: "npm run lint:native", desc: "Running clang-tidy" });
+}
+
+// Run comprehensive memory tests (cross-platform)
+// This includes Windows debug memory check on Windows
+run({ cmd: "npm run check:memory", desc: "Comprehensive memory tests" });
+
+console.log("\n✅ All precommit checks passed!");

package/scripts/sanitizers-test.sh

@@ -76,7 +76,8 @@ fi
 
 # Build the native module
 echo "Building with AddressSanitizer..."
-npm run configure:native
+npm run setup:native
+npm run clean:native
 npm run node-gyp-rebuild
 
 # Run tests and capture output
@@ -148,4 +149,9 @@ if [[ "$VERBOSE" -eq 1 ]] && grep -q "Stats:" "$OUTPUT_FILE"; then
     grep -A 20 "Stats:" "$OUTPUT_FILE" | head -20
 fi
 
+# Clean build artifacts to ensure no ASAN-compiled code remains
+echo -e "\n${YELLOW}Cleaning build artifacts...${NC}"
+npm run clean:native > /dev/null 2>&1
+echo -e "${GREEN}✓ Build artifacts cleaned${NC}"
+
 exit $EXIT_CODE

package/scripts/{configure.mjs → setup-native.mjs}

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
-// scripts/configure.mjs
+// 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";

package/src/binding.cpp

@@ -93,6 +93,6 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   return exports;
 }
 
-NODE_API_MODULE(node_fs_meta, Init)
+NODE_API_MODULE(fs_metadata, Init)
 
 } // namespace

package/src/common/error_utils.h

@@ -18,12 +18,6 @@ inline std::string CreateErrorMessage(const char *operation, int error) {
          " 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) {

package/src/common/volume_metadata.h

@@ -8,6 +8,8 @@ struct VolumeMetadataOptions {
   std::string mountPoint;    // Required mount point path
   uint32_t timeoutMs = 5000; // Optional timeout with default
   std::string device;        // Optional device path
+  bool skipNetworkVolumes =
+      false; // Skip detailed info for network volumes to avoid blocking
 
   static VolumeMetadataOptions FromObject(const Napi::Object &obj) {
     VolumeMetadataOptions options;
@@ -25,6 +27,10 @@ struct VolumeMetadataOptions {
     if (obj.Has("device")) {
       options.device = obj.Get("device").As<Napi::String>();
     }
+    if (obj.Has("skipNetworkVolumes")) {
+      options.skipNetworkVolumes =
+          obj.Get("skipNetworkVolumes").As<Napi::Boolean>().Value();
+    }
 
     return options;
   }