@rljson/fs-agent 0.0.22 → 0.0.23

package/dist/fs-agent.d.ts

@@ -131,6 +131,21 @@ export declare const ATOMIC_TMP_PREFIX = ".fsagent-tmp-";
 /**
  * Orchestrates filesystem operations with tree structures and blob storage
  */
+/**
+ * Thrown when a restore wrote everything it could but at least one file was
+ * held open by another process.
+ *
+ * Not a failure of the restore so much as a "not yet": the bytes are still
+ * available, the file is simply busy. It is an error rather than a silent
+ * partial success because the folder does NOT match the tree afterwards, and
+ * anything that treats it as if it did — advertising the state, recording the
+ * ref as applied — would make one locked file look like an edit that everyone
+ * else must adopt.
+ */
+export declare class PartialRestoreError extends Error {
+    readonly lockedPaths: string[];
+    constructor(lockedPaths: string[]);
+}
 export declare class FsAgent {
     private _scanner;
     private _adapter;
@@ -162,6 +177,8 @@ export declare class FsAgent {
     /** Files written vs left alone by the current {@link restore}. */
     private _restoreWritten;
     private _restoreSkipped;
+    /** Paths the current {@link restore} could not write because they were held open. */
+    private _restoreLocked;
     /**
      * What this agent last wrote to each absolute path, so a repeat restore can
      * recognise its own work without re-reading the file.
@@ -304,6 +321,17 @@ export declare class FsAgent {
      *   is the only case where the scanner's view describes these files
      */
     private _restoreTree;
+    /**
+     * Whether a caught value means "another process is holding this file".
+     *
+     * Windows reports a locked file as EPERM or EBUSY; EACCES covers the
+     * permission-denied shape. Deliberately narrow — anything else is a real
+     * write failure and must still abort, because a restore that shrugged off
+     * every error would report success while leaving the folder wrong.
+     * @param err - The caught value.
+     * @returns `true` for a lock-shaped error.
+     */
+    private static _isLocked;
     /**
      * The content identity this agent believes is on disk at `filePath`, or
      * `undefined` when it has no basis for an opinion.

package/dist/fs-agent.js

@@ -1022,6 +1022,15 @@ const DEFAULT_TIMEOUTS = {
 const DISCONNECT_PAUSE_MAX_MS = 3e4;
 const SYNC_ERROR_FILE = ".sync-errors.log";
 const ATOMIC_TMP_PREFIX = ".fsagent-tmp-";
+class PartialRestoreError extends Error {
+  constructor(lockedPaths) {
+    super(
+      `restore could not write ${lockedPaths.length} locked file${lockedPaths.length === 1 ? "" : "s"}: ${lockedPaths.join(", ")}`
+    );
+    this.lockedPaths = lockedPaths;
+    this.name = "PartialRestoreError";
+  }
+}
 class FsAgent {
   _scanner;
   _adapter;
@@ -1053,6 +1062,8 @@ class FsAgent {
   /** Files written vs left alone by the current {@link restore}. */
   _restoreWritten = 0;
   _restoreSkipped = 0;
+  /** Paths the current {@link restore} could not write because they were held open. */
+  _restoreLocked = [];
   /**
    * What this agent last wrote to each absolute path, so a repeat restore can
    * recognise its own work without re-reading the file.
@@ -1323,6 +1334,7 @@ ${err.stack}` : String(err);
     const preRestore = options?.cleanTarget ? await this._collectAllFiles(target) : /* @__PURE__ */ new Set();
     this._restoreWritten = 0;
     this._restoreSkipped = 0;
+    this._restoreLocked = [];
     await this._restoreTree(
       tree.rootHash,
       tree.trees,
@@ -1342,6 +1354,9 @@ ${err.stack}` : String(err);
         preRestore
       );
     }
+    if (this._restoreLocked.length > 0) {
+      throw new PartialRestoreError([...this._restoreLocked]);
+    }
   }
   /**
    * Recursively collects the absolute paths of all files under `currentDir`.
@@ -1406,18 +1421,26 @@ ${err.stack}` : String(err);
           );
         }
         await mkdir(dirname(filePath), { recursive: true });
-        await FsAgent._atomicWriteFile(filePath, fileBlob.content);
-        this._restoreWritten++;
-        if (meta.mtime) {
-          const mtime = new Date(meta.mtime);
-          await utimes(filePath, mtime, mtime);
-        }
-        if (meta.size !== void 0 && meta.mtime !== void 0) {
-          this._restoredBlobs.set(filePath, {
-            blobId: meta.blobId,
-            size: meta.size,
-            mtime: meta.mtime
-          });
+        try {
+          await FsAgent._atomicWriteFile(filePath, fileBlob.content);
+          this._restoreWritten++;
+          if (meta.mtime) {
+            const mtime = new Date(meta.mtime);
+            await utimes(filePath, mtime, mtime);
+          }
+          if (meta.size !== void 0 && meta.mtime !== void 0) {
+            this._restoredBlobs.set(filePath, {
+              blobId: meta.blobId,
+              size: meta.size,
+              mtime: meta.mtime
+            });
+          }
+        } catch (error) {
+          if (!FsAgent._isLocked(error)) throw error;
+          console.warn(
+            `[FsAgent] restore: "${meta.relativePath}" is held open by another process (${error.code}) — skipped, will retry`
+          );
+          this._restoreLocked.push(meta.relativePath);
         }
       }
     } else if (meta.type === "directory") {
@@ -1430,6 +1453,20 @@ ${err.stack}` : String(err);
       }
     }
   }
+  /**
+   * Whether a caught value means "another process is holding this file".
+   *
+   * Windows reports a locked file as EPERM or EBUSY; EACCES covers the
+   * permission-denied shape. Deliberately narrow — anything else is a real
+   * write failure and must still abort, because a restore that shrugged off
+   * every error would report success while leaving the folder wrong.
+   * @param err - The caught value.
+   * @returns `true` for a lock-shaped error.
+   */
+  static _isLocked(err) {
+    const code = err?.code;
+    return code === "EPERM" || code === "EBUSY" || code === "EACCES";
+  }
   /**
    * The content identity this agent believes is on disk at `filePath`, or
    * `undefined` when it has no basis for an opinion.
@@ -2119,6 +2156,13 @@ ${err.stack}` : String(err);
           this._currentRef = postRestoreRef;
           return;
         } catch (err) {
+          if (err instanceof PartialRestoreError) {
+            try {
+              const halfApplied = await this._scanner.scan();
+              this._lastSentContentKey = this._contentKeyFromTree(halfApplied);
+            } catch {
+            }
+          }
           if (attempt === maxAttempts) {
             if (recoveryAttempt >= this._timeouts.recoveryRetries) {
               console.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/fs-agent",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "Rljson fs-agent description",
   "homepage": "https://github.com/rljson/fs-agent",
   "bugs": "https://github.com/rljson/fs-agent/issues",