@uipath/filesystem 1.1.0 → 1.196.0

package/dist/browser.d.ts

@@ -19,6 +19,9 @@ export declare class BrowserFileSystem implements IFileSystem {
     stat(path: string): Promise<FileSystemStats | null>;
     exists(path: string): Promise<boolean>;
     mkdir(path: string): Promise<void>;
+    acquireLock(lockPath: string): Promise<() => Promise<void>>;
+    private acquireWebLock;
+    private acquireInMemoryLock;
     rm(path: string): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
     realpath(filePath: string): Promise<string>;

package/dist/index.browser.js

@@ -1389,6 +1389,23 @@ var require_src = __commonJS((exports, module) => {
 
 // src/browser.ts
 var import_lightning_fs = __toESM(require_src(), 1);
+var LOCK_MAX_WAIT_MS = 20000;
+var IN_MEMORY_LOCK_TAILS_KEY = Symbol.for("@uipath/filesystem/lock-tails");
+var getInMemoryLockTails = () => {
+  const globalsHost = globalThis;
+  const existing = globalsHost[IN_MEMORY_LOCK_TAILS_KEY];
+  if (existing && typeof existing.get === "function" && typeof existing.set === "function" && typeof existing.delete === "function") {
+    return existing;
+  }
+  const created = new Map;
+  globalsHost[IN_MEMORY_LOCK_TAILS_KEY] = created;
+  return created;
+};
+var getWebLocks = () => {
+  if (typeof navigator === "undefined")
+    return;
+  return navigator.locks;
+};
 
 class BrowserFileSystem {
   initialized = false;
@@ -1571,6 +1588,69 @@ class BrowserFileSystem {
       throw error;
     }
   }
+  async acquireLock(lockPath) {
+    const canonical = this.normalizePath(this.path.isAbsolute(lockPath) ? lockPath : `/${lockPath}`);
+    const name = `@uipath/filesystem:lock:${canonical}`;
+    const webLocks = getWebLocks();
+    if (webLocks) {
+      return await this.acquireWebLock(webLocks, name);
+    }
+    return this.acquireInMemoryLock(name);
+  }
+  async acquireWebLock(webLocks, name) {
+    const abortController = new AbortController;
+    const timeoutHandle = setTimeout(() => {
+      abortController.abort();
+    }, LOCK_MAX_WAIT_MS);
+    return await new Promise((resolveAcquire, rejectAcquire) => {
+      let releaseHeld;
+      const requested = webLocks.request(name, { signal: abortController.signal }, () => new Promise((resolveHeld) => {
+        clearTimeout(timeoutHandle);
+        releaseHeld = resolveHeld;
+        resolveAcquire(async () => {
+          resolveHeld();
+        });
+      }));
+      requested.catch((error) => {
+        clearTimeout(timeoutHandle);
+        if (releaseHeld) {
+          return;
+        }
+        if (error?.name === "AbortError") {
+          rejectAcquire(new Error(`ELOCKED: timed out waiting for lock on ${name}`));
+          return;
+        }
+        rejectAcquire(error);
+      });
+    });
+  }
+  acquireInMemoryLock(name) {
+    const tails = getInMemoryLockTails();
+    const prior = tails.get(name) ?? Promise.resolve();
+    let releaseHeld;
+    const held = new Promise((resolve) => {
+      releaseHeld = resolve;
+    });
+    const chained = prior.then(() => held);
+    tails.set(name, chained);
+    chained.then(() => {
+      if (tails.get(name) === chained) {
+        tails.delete(name);
+      }
+    });
+    return new Promise((resolveAcquire, rejectAcquire) => {
+      const timer = setTimeout(() => {
+        releaseHeld();
+        rejectAcquire(new Error(`ELOCKED: timed out waiting for lock on ${name}`));
+      }, LOCK_MAX_WAIT_MS);
+      prior.then(() => {
+        clearTimeout(timer);
+        resolveAcquire(async () => {
+          releaseHeld();
+        });
+      });
+    });
+  }
   async rm(path) {
     await this.init();
     const fs = this.getFs();

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/node.ts
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import * as fs6 from "node:fs/promises";
 import * as os2 from "node:os";
@@ -615,6 +616,13 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({
 var open_default = open;
 
 // src/node.ts
+var LOCK_HEARTBEAT_MS = 5000;
+var LOCK_STALE_MS = 15000;
+var LOCK_MAX_WAIT_MS = 20000;
+var LOCK_MAX_HOLD_MS = 60000;
+var LOCK_RETRY_MIN_MS = 100;
+var LOCK_RETRY_JITTER_MS = 200;
+
 class NodeFileSystem {
   path = {
     join: path2.join,
@@ -691,6 +699,90 @@ class NodeFileSystem {
   async mkdir(dirPath) {
     await fs6.mkdir(dirPath, { recursive: true });
   }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs6.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
+        }
+        const stats = await fs6.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs6.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
+      }
+    }
+  }
+  async canonicalizeLockTarget(lockPath) {
+    const absolute = path2.resolve(lockPath);
+    const fullReal = await fs6.realpath(absolute).catch(() => null);
+    if (fullReal)
+      return fullReal;
+    const parent = path2.dirname(absolute);
+    const base = path2.basename(absolute);
+    const canonicalParent = await fs6.realpath(parent).catch(() => parent);
+    return path2.join(canonicalParent, base);
+  }
+  createLockRelease(lockFile, ownerId) {
+    const heartbeatStart = Date.now();
+    let heartbeatTimer;
+    let stopped = false;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (heartbeatTimer)
+        clearTimeout(heartbeatTimer);
+    };
+    const scheduleNextHeartbeat = () => {
+      if (stopped)
+        return;
+      if (Date.now() - heartbeatStart >= LOCK_MAX_HOLD_MS) {
+        stopped = true;
+        return;
+      }
+      heartbeatTimer = setTimeout(() => {
+        runHeartbeat();
+      }, LOCK_HEARTBEAT_MS);
+      heartbeatTimer.unref?.();
+    };
+    const runHeartbeat = async () => {
+      if (stopped)
+        return;
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (stopped)
+        return;
+      if (current !== ownerId) {
+        stopped = true;
+        return;
+      }
+      const now = Date.now() / 1000;
+      await fs6.utimes(lockFile, now, now).catch(() => {});
+      scheduleNextHeartbeat();
+    };
+    scheduleNextHeartbeat();
+    let released = false;
+    return async () => {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (current === ownerId) {
+        await fs6.rm(lockFile, { force: true });
+      }
+    };
+  }
   async rm(filePath) {
     await fs6.rm(filePath, { recursive: true, force: true });
   }
@@ -736,7 +828,10 @@ class NodeFileSystem {
     }
   }
   isEnoent(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    return this.hasErrnoCode(error, "ENOENT");
+  }
+  hasErrnoCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
   }
 }
 

package/dist/interfaces.d.ts

@@ -32,6 +32,41 @@ export interface IFileSystem {
     stat(path: string): Promise<FileSystemStats | null>;
     exists(path: string): Promise<boolean>;
     mkdir(path: string): Promise<void>;
+    /**
+     * Acquire a cross-process advisory lock for `path`, serializing work
+     * across concurrent processes that would otherwise race on the same
+     * file (e.g. one-time-use auth refresh tokens). Resolves to a release
+     * function — call it in a `finally` (wrapped in try/catch) to free the
+     * lock.
+     *
+     * Node claims a sibling `<path>.lock` file via an atomic create-or-fail
+     * write (`O_CREAT | O_EXCL`, fail-on-`EEXIST`) carrying a random owner
+     * id, retrying with jitter; while held, a self-rescheduling heartbeat
+     * keeps the lock fresh so a live holder is never reclaimed, and a
+     * holder that stops heartbeating (crashed/hung, or held longer than
+     * the heartbeat-lifetime cap) is reclaimed as stale. Acquisition
+     * rejects with an `ELOCKED` error after a timeout; release removes the
+     * lock only if this process still owns it, and may itself reject if
+     * that removal fails (e.g. `EACCES`).
+     *
+     * Browser prefers the Web Locks API (`navigator.locks`), which
+     * coordinates across same-origin tabs, workers, and the service
+     * worker. When `navigator.locks` is unavailable (older runtimes,
+     * non-window contexts) it falls back to an in-tab promise chain —
+     * serialization within the tab only. LightningFS is per-tab anyway,
+     * so a stored lock file could not coordinate cross-tab either.
+     *
+     * `path` is normalized before use so two callers passing distinct
+     * strings that resolve to the same file share a single lock — Node
+     * absolutizes via CWD and realpaths the full target (collapsing
+     * symlinks on both parent and basename), falling back to
+     * realpath-of-parent + lexical basename when the target file does
+     * not exist yet (e.g. first-run auth file). Browser collapses
+     * `.`/`..` segments and treats relative paths as rooted at `/`.
+     * Pass the same logical path consistently across callers; do NOT
+     * rely on case-insensitive collapsing on Windows or macOS.
+     */
+    acquireLock(path: string): Promise<() => Promise<void>>;
     rm(path: string): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
     /**

package/dist/node.d.ts

@@ -13,10 +13,14 @@ export declare class NodeFileSystem implements IFileSystem {
     stat(filePath: string): Promise<FileSystemStats | null>;
     exists(filePath: string): Promise<boolean>;
     mkdir(dirPath: string): Promise<void>;
+    acquireLock(lockPath: string): Promise<() => Promise<void>>;
+    private canonicalizeLockTarget;
+    private createLockRelease;
     rm(filePath: string): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
     realpath(filePath: string): Promise<string>;
     getTempDir(): Promise<string>;
     copyDirectory(sourcePath: string, destPath: string): Promise<void>;
     private isEnoent;
+    private hasErrnoCode;
 }

package/package.json

@@ -1,47 +1,41 @@
 {
-    "name": "@uipath/filesystem",
-    "version": "1.1.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/UiPath/cli.git",
-        "directory": "packages/filesystem"
+  "name": "@uipath/filesystem",
+  "license": "MIT",
+  "version": "1.196.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UiPath/cli.git",
+    "directory": "packages/filesystem"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
     },
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/"
-    },
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "browser": {
-                "types": "./dist/index.browser.d.ts",
-                "default": "./dist/index.browser.js"
-            },
-            "default": {
-                "types": "./dist/index.d.ts",
-                "default": "./dist/index.js"
-            }
-        },
-        "./browser": {
-            "types": "./dist/index.browser.d.ts",
-            "default": "./dist/index.browser.js"
-        }
-    },
-    "files": [
-        "dist"
-    ],
-    "maintainers": [
-        "aoltean16",
-        "mihaigirleanu",
-        "vlad-uipath"
-    ],
-    "devDependencies": {
-        "@isomorphic-git/lightning-fs": "^4.6.2",
-        "@types/node": "^25.5.2",
-        "fake-indexeddb": "^6.2.4",
-        "open": "^11.0.0",
-        "typescript": "^6.0.2"
-    },
-    "gitHead": "06e8c8f566df4b87da4a008635483c62f64f33f0"
+    "./browser": {
+      "types": "./dist/index.browser.d.ts",
+      "default": "./dist/index.browser.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "maintainers": [
+    "aoltean16",
+    "mihaigirleanu",
+    "vlad-uipath"
+  ],
+  "gitHead": "94d71f9c52214980a1f0ae62b3f5372095788553"
 }