cclaw-cli 0.48.17 → 0.48.18

package/dist/content/node-hooks.js

@@ -118,26 +118,54 @@ async function writeFileAtomic(filePath, content, options = {}) {
     "." + path.basename(filePath) + ".tmp-" + process.pid + "-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8)
   );
   await fs.writeFile(tempPath, content, { encoding: "utf8" });
-  try {
-    await fs.rename(tempPath, filePath);
-    if (options.mode !== undefined) {
-      await fs.chmod(filePath, options.mode).catch(() => undefined);
-    }
-  } catch (error) {
-    const code = error && typeof error === "object" && "code" in error ? error.code : null;
-    if (code === "EXDEV") {
-      try {
-        await fs.copyFile(tempPath, filePath);
-      } finally {
-        await fs.unlink(tempPath).catch(() => undefined);
-      }
+  // Windows' fs.rename can fail transiently with EPERM/EBUSY/EACCES when the
+  // destination file is held open by another process (antivirus, indexer,
+  // or a sibling hook invocation racing on the same file). Retry with tiny
+  // backoff before falling back to copyFile.
+  const renameRetryableCodes = new Set(["EPERM", "EBUSY", "EACCES"]);
+  let attempt = 0;
+  const maxAttempts = 6;
+  while (true) {
+    try {
+      await fs.rename(tempPath, filePath);
       if (options.mode !== undefined) {
         await fs.chmod(filePath, options.mode).catch(() => undefined);
       }
       return;
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : null;
+      if (code === "EXDEV") {
+        try {
+          await fs.copyFile(tempPath, filePath);
+        } finally {
+          await fs.unlink(tempPath).catch(() => undefined);
+        }
+        if (options.mode !== undefined) {
+          await fs.chmod(filePath, options.mode).catch(() => undefined);
+        }
+        return;
+      }
+      if (renameRetryableCodes.has(code) && attempt < maxAttempts) {
+        attempt += 1;
+        await hookSleep(10 * attempt + Math.floor(Math.random() * 10));
+        continue;
+      }
+      if (renameRetryableCodes.has(code)) {
+        // Last-resort fallback: copy-then-unlink. Not atomic, but the
+        // directory lock around this call already serializes writers.
+        try {
+          await fs.copyFile(tempPath, filePath);
+          if (options.mode !== undefined) {
+            await fs.chmod(filePath, options.mode).catch(() => undefined);
+          }
+          return;
+        } finally {
+          await fs.unlink(tempPath).catch(() => undefined);
+        }
+      }
+      await fs.unlink(tempPath).catch(() => undefined);
+      throw error;
     }
-    await fs.unlink(tempPath).catch(() => undefined);
-    throw error;
   }
 }
 

package/dist/fs-utils.js

@@ -75,35 +75,67 @@ export async function writeFileSafe(filePath, content, options = {}) {
     const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
     const targetMode = options.mode;
     await fs.writeFile(tempPath, content, { encoding: "utf8", ...(targetMode !== undefined ? { mode: targetMode } : {}) });
-    try {
-        await fs.rename(tempPath, filePath);
-        if (targetMode !== undefined) {
-            await fs.chmod(filePath, targetMode).catch(() => undefined);
+    // On Windows, `fs.rename` can fail transiently with EPERM / EBUSY / EACCES
+    // when the target file is briefly held open by another process (antivirus,
+    // search indexer, or a concurrent cclaw hook). Retry with small backoff
+    // before falling back to a non-atomic copy + unlink.
+    const renameRetryableCodes = new Set(["EPERM", "EBUSY", "EACCES"]);
+    let attempt = 0;
+    const maxAttempts = 6;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            await fs.rename(tempPath, filePath);
+            if (targetMode !== undefined) {
+                await fs.chmod(filePath, targetMode).catch(() => undefined);
+            }
+            return;
         }
-    }
-    catch (error) {
-        const code = error?.code;
-        // `rename` fails with EXDEV when the temp file and target live on
-        // different filesystems (container bind mounts, tmpfs + rootfs,
-        // cross-volume setups). Fall back to copy + unlink so atomic writes
-        // still work — copyFile is not fully atomic but is the best we can
-        // do across devices, and we remove the temp even if copy fails.
-        if (code === "EXDEV") {
-            try {
-                await fs.copyFile(tempPath, filePath);
-                if (targetMode !== undefined) {
-                    await fs.chmod(filePath, targetMode).catch(() => undefined);
+        catch (error) {
+            const code = error?.code;
+            // `rename` fails with EXDEV when the temp file and target live on
+            // different filesystems (container bind mounts, tmpfs + rootfs,
+            // cross-volume setups). Fall back to copy + unlink so atomic writes
+            // still work — copyFile is not fully atomic but is the best we can
+            // do across devices, and we remove the temp even if copy fails.
+            if (code === "EXDEV") {
+                try {
+                    await fs.copyFile(tempPath, filePath);
+                    if (targetMode !== undefined) {
+                        await fs.chmod(filePath, targetMode).catch(() => undefined);
+                    }
+                }
+                finally {
+                    await fs.unlink(tempPath).catch(() => undefined);
                 }
+                return;
             }
-            finally {
-                await fs.unlink(tempPath).catch(() => undefined);
+            if (code !== undefined && renameRetryableCodes.has(code) && attempt < maxAttempts) {
+                attempt += 1;
+                const waitMs = 10 * attempt + Math.floor(Math.random() * 10);
+                await new Promise((resolve) => setTimeout(resolve, waitMs));
+                continue;
             }
-            return;
+            if (code !== undefined && renameRetryableCodes.has(code)) {
+                // Last-resort fallback on Windows: copy-then-unlink. Not atomic,
+                // but the caller is expected to have serialized via a directory
+                // lock so this only loses atomicity under extreme contention.
+                try {
+                    await fs.copyFile(tempPath, filePath);
+                    if (targetMode !== undefined) {
+                        await fs.chmod(filePath, targetMode).catch(() => undefined);
+                    }
+                    return;
+                }
+                finally {
+                    await fs.unlink(tempPath).catch(() => undefined);
+                }
+            }
+            // Other errors: try to clean up the temp to avoid littering the
+            // directory with orphaned `.tmp-<pid>-*` files, then rethrow.
+            await fs.unlink(tempPath).catch(() => undefined);
+            throw error;
         }
-        // Other errors: try to clean up the temp to avoid littering the
-        // directory with orphaned `.tmp-<pid>-*` files, then rethrow.
-        await fs.unlink(tempPath).catch(() => undefined);
-        throw error;
     }
 }
 export async function exists(filePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.48.17",
+  "version": "0.48.18",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {