chore: bump version

Author: sonofmagic

.changeset/fix-windows-cache-lock.md

@@ -0,0 +1,5 @@
+---
+'tailwindcss-patch': patch
+---
+
+Gracefully skip cache updates when the cache file is locked on Windows to avoid EPERM failures.

packages/tailwindcss-patch/src/cache/store.ts

@@ -7,6 +7,11 @@ function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
   return error instanceof Error && typeof (error as NodeJS.ErrnoException).code === 'string'
 }
 
+function isAccessDenied(error: unknown): error is NodeJS.ErrnoException {
+  return isErrnoException(error)
+    && Boolean(error.code && ['EPERM', 'EBUSY', 'EACCES'].includes(error.code))
+}
+
 export class CacheStore {
   constructor(private readonly options: NormalizedCacheOptions) {}
 
@@ -23,46 +28,58 @@ export class CacheStore {
     return `${this.options.path}.${uniqueSuffix}.tmp`
   }
 
-  private async replaceCacheFile(tempPath: string) {
+  private async replaceCacheFile(tempPath: string): Promise<boolean> {
     try {
       await fs.rename(tempPath, this.options.path)
+      return true
     }
     catch (error) {
       if (isErrnoException(error) && (error.code === 'EEXIST' || error.code === 'EPERM')) {
         try {
           await fs.remove(this.options.path)
         }
         catch (removeError) {
+          if (isAccessDenied(removeError)) {
+            logger.debug('Tailwind class cache locked or read-only, skipping update.', removeError)
+            return false
+          }
+
           if (!isErrnoException(removeError) || removeError.code !== 'ENOENT') {
             throw removeError
           }
         }
 
         await fs.rename(tempPath, this.options.path)
-        return
+        return true
       }
 
       throw error
     }
   }
 
-  private replaceCacheFileSync(tempPath: string) {
+  private replaceCacheFileSync(tempPath: string): boolean {
     try {
       fs.renameSync(tempPath, this.options.path)
+      return true
     }
     catch (error) {
       if (isErrnoException(error) && (error.code === 'EEXIST' || error.code === 'EPERM')) {
         try {
           fs.removeSync(this.options.path)
         }
         catch (removeError) {
+          if (isAccessDenied(removeError)) {
+            logger.debug('Tailwind class cache locked or read-only, skipping update.', removeError)
+            return false
+          }
+
           if (!isErrnoException(removeError) || removeError.code !== 'ENOENT') {
             throw removeError
           }
         }
 
         fs.renameSync(tempPath, this.options.path)
-        return
+        return true
       }
 
       throw error
@@ -94,8 +111,13 @@ export class CacheStore {
       await this.ensureDir()
       // Persist to a temp file first so concurrent writers never expose partial JSON
       await fs.writeJSON(tempPath, Array.from(data))
-      await this.replaceCacheFile(tempPath)
-      return this.options.path
+      const replaced = await this.replaceCacheFile(tempPath)
+      if (replaced) {
+        return this.options.path
+      }
+
+      await this.cleanupTempFile(tempPath)
+      return undefined
     }
     catch (error) {
       await this.cleanupTempFile(tempPath)
@@ -114,8 +136,13 @@ export class CacheStore {
     try {
       this.ensureDirSync()
       fs.writeJSONSync(tempPath, Array.from(data))
-      this.replaceCacheFileSync(tempPath)
-      return this.options.path
+      const replaced = this.replaceCacheFileSync(tempPath)
+      if (replaced) {
+        return this.options.path
+      }
+
+      this.cleanupTempFileSync(tempPath)
+      return undefined
     }
     catch (error) {
       this.cleanupTempFileSync(tempPath)

packages/tailwindcss-patch/test/cache.store.test.ts

@@ -202,4 +202,95 @@ describe('CacheStore', () => {
     pathExistsSpy.mockRestore()
     readSpy.mockRestore()
   })
+
+  it('skips cache writes when the destination cannot be removed (async)', async () => {
+    const cachePath = path.join(tempDir, 'cache.json')
+    await fs.writeJSON(cachePath, ['old'])
+
+    const store = new CacheStore({
+      enabled: true,
+      cwd: tempDir,
+      dir: tempDir,
+      file: 'cache.json',
+      path: cachePath,
+      strategy: 'merge',
+    })
+
+    const writeJSONSpy = vi.spyOn(fs, 'writeJSON')
+    const debugSpy = vi.spyOn(logger, 'debug')
+    const renameSpy = vi.spyOn(fs, 'rename').mockRejectedValueOnce(
+      Object.assign(new Error('exists'), { code: 'EEXIST' as NodeJS.ErrnoException['code'] }),
+    )
+    const realRemove = fs.remove
+    let removeAttempts = 0
+    const removeSpy = vi.spyOn(fs, 'remove').mockImplementation(async (...args) => {
+      removeAttempts += 1
+      if (removeAttempts === 1) {
+        const error = Object.assign(new Error('locked'), { code: 'EPERM' as NodeJS.ErrnoException['code'] })
+        throw error
+      }
+      return realRemove.apply(fs, args as Parameters<typeof fs.remove>)
+    })
+
+    const result = await store.write(new Set(['fresh']))
+    expect(result).toBeUndefined()
+    expect(renameSpy).toHaveBeenCalledTimes(1)
+    expect(removeSpy).toHaveBeenCalledTimes(2)
+    expect(debugSpy).toHaveBeenCalled()
+
+    const tempPath = writeJSONSpy.mock.calls[0]?.[0] as string
+    expect(tempPath).toBeTruthy()
+    expect(await fs.pathExists(tempPath)).toBe(false)
+
+    writeJSONSpy.mockRestore()
+    debugSpy.mockRestore()
+    renameSpy.mockRestore()
+    removeSpy.mockRestore()
+  })
+
+  it('skips cache writes when the destination cannot be removed (sync)', () => {
+    const cachePath = path.join(tempDir, 'cache.json')
+    fs.writeJSONSync(cachePath, ['old'])
+
+    const store = new CacheStore({
+      enabled: true,
+      cwd: tempDir,
+      dir: tempDir,
+      file: 'cache.json',
+      path: cachePath,
+      strategy: 'merge',
+    })
+
+    const writeJSONSpy = vi.spyOn(fs, 'writeJSONSync')
+    const debugSpy = vi.spyOn(logger, 'debug')
+    const renameSpy = vi.spyOn(fs, 'renameSync').mockImplementationOnce(() => {
+      const error = Object.assign(new Error('exists'), { code: 'EEXIST' as NodeJS.ErrnoException['code'] })
+      throw error
+    })
+    const realRemove = fs.removeSync
+    let removeAttempts = 0
+    const removeSpy = vi.spyOn(fs, 'removeSync').mockImplementation((...args) => {
+      removeAttempts += 1
+      if (removeAttempts === 1) {
+        const error = Object.assign(new Error('locked'), { code: 'EPERM' as NodeJS.ErrnoException['code'] })
+        throw error
+      }
+      return realRemove.apply(fs, args as Parameters<typeof fs.removeSync>)
+    })
+
+    const result = store.writeSync(new Set(['fresh']))
+    expect(result).toBeUndefined()
+    expect(renameSpy).toHaveBeenCalledTimes(1)
+    expect(removeSpy).toHaveBeenCalledTimes(2)
+    expect(debugSpy).toHaveBeenCalled()
+
+    const tempPath = writeJSONSpy.mock.calls[0]?.[0] as string
+    expect(tempPath).toBeTruthy()
+    expect(fs.pathExistsSync(tempPath)).toBe(false)
+
+    writeJSONSpy.mockRestore()
+    debugSpy.mockRestore()
+    renameSpy.mockRestore()
+    removeSpy.mockRestore()
+  })
 })