@wrongstack/persistence 0.317.0 → 0.318.0

package/dist/index.js

@@ -35,8 +35,8 @@ function createPersistencePrimitives(options = {}) {
     let mode;
     let existing;
     try {
-      const stat2 = await fs.stat(targetPath);
-      existing = stat2.mode & 511;
+      const stat3 = await fs.stat(targetPath);
+      existing = stat3.mode & 511;
     } catch {
       existing = void 0;
     }
@@ -139,10 +139,10 @@ function createPersistencePrimitives(options = {}) {
           throw error;
         }
         try {
-          const stat2 = await fs.stat(lockPath);
-          if (Date.now() - stat2.mtimeMs > staleMs) {
+          const stat3 = await fs.stat(lockPath);
+          if (Date.now() - stat3.mtimeMs > staleMs) {
             const recheck = await fs.stat(lockPath).catch(() => void 0);
-            if (recheck && recheck.mtimeMs === stat2.mtimeMs && Date.now() - recheck.mtimeMs > staleMs) {
+            if (recheck && recheck.mtimeMs === stat3.mtimeMs && Date.now() - recheck.mtimeMs > staleMs) {
               await fs.unlink(lockPath).catch(() => void 0);
             }
             await retryAfterBackoff();
@@ -258,7 +258,19 @@ var ensureDir = defaultPrimitives.ensureDir;
 var withFileLock = defaultPrimitives.withFileLock;
 
 // src/file-permissions.ts
-import { chmod as chmod2 } from "node:fs/promises";
+import * as childProcess from "node:child_process";
+import { chmod as chmod2, stat as stat2 } from "node:fs/promises";
+import { promisify } from "node:util";
+var _execFileAsync;
+function getExecFileAsync() {
+  if (!_execFileAsync) {
+    const fn = childProcess.execFile;
+    if (typeof fn === "function") {
+      _execFileAsync = promisify(fn);
+    }
+  }
+  return _execFileAsync;
+}
 var SECRET_FILE_MODE = 384;
 var SECRET_DIR_MODE = 448;
 async function restrictFilePermissions(filePath, opts) {
@@ -266,9 +278,6 @@ async function restrictFilePermissions(filePath, opts) {
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   if (process.platform === "win32") {
     try {
-      const { execFile } = await import("node:child_process");
-      const { promisify } = await import("node:util");
-      const execFileAsync = promisify(execFile);
       const user = windowsAccountName();
       if (!user) {
         warn(
@@ -276,12 +285,19 @@ async function restrictFilePermissions(filePath, opts) {
         );
         return;
       }
-      await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${user}:(F)`], {
+      const execFn = getExecFileAsync();
+      if (!execFn) {
+        warn(`[${label}] child_process.execFile unavailable on this platform.`);
+        return;
+      }
+      await execFn("icacls", [filePath, "/inheritance:r", "/grant:r", `${user}:(F)`], {
         windowsHide: true
       });
-    } catch {
+    } catch (error) {
+      if (await pathIsGone(filePath)) return;
+      const reason = error instanceof Error ? error.message : String(error);
       warn(
-        `[${label}] Could not restrict permissions on ${filePath} \u2014 it may be readable by other users on this system.`
+        `[${label}] Could not restrict permissions on ${filePath} (${reason}) \u2014 it may be readable by other users on this system.`
       );
     }
   } else {
@@ -291,6 +307,14 @@ async function restrictFilePermissions(filePath, opts) {
     }
   }
 }
+async function pathIsGone(filePath) {
+  try {
+    await stat2(filePath);
+    return false;
+  } catch {
+    return true;
+  }
+}
 async function restrictDirPermissions(dirPath, opts) {
   if (process.platform === "win32") {
     await restrictFilePermissions(dirPath, opts);
@@ -320,10 +344,10 @@ function unixSocketPathLimit(platform = process.platform) {
   return 107;
 }
 function checkUnixSocketPath(socketPath, platform = process.platform) {
-  const byteLength = Buffer.byteLength(socketPath, "utf8");
   if (platform === "win32") {
-    return { ok: true, byteLength, maxBytes: Number.MAX_SAFE_INTEGER };
+    return { ok: true, byteLength: socketPath.length, maxBytes: Number.MAX_SAFE_INTEGER };
   }
+  const byteLength = Buffer.byteLength(socketPath, "utf8");
   const maxBytes = unixSocketPathLimit(platform);
   return { ok: byteLength <= maxBytes, byteLength, maxBytes };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/persistence",
-  "version": "0.317.0",
+  "version": "0.318.0",
   "license": "MIT",
   "description": "Dependency-free filesystem persistence primitives shared across WrongStack packages.",
   "repository": {