fix(filesystem): clean up temp files on fallback failures

Author: Chelebii

src/filesystem/__tests__/lib.test.ts

@@ -363,6 +363,48 @@ describe('Lib Functions', () => {
           { force: true }
         );
       });
+
+      it('cleans up temp file and re-throws when fs.cp fails after EPERM', async () => {
+        const eexistError = new Error('EEXIST') as NodeJS.ErrnoException;
+        eexistError.code = 'EEXIST';
+        const epermError = new Error('EPERM') as NodeJS.ErrnoException;
+        epermError.code = 'EPERM';
+        const enospcError = new Error('ENOSPC') as NodeJS.ErrnoException;
+        enospcError.code = 'ENOSPC';
+
+        mockFs.writeFile
+          .mockRejectedValueOnce(eexistError)
+          .mockResolvedValueOnce(undefined);
+        mockFs.rename.mockRejectedValueOnce(epermError);
+        mockFs.cp.mockRejectedValueOnce(enospcError);
+        mockFs.unlink.mockResolvedValue(undefined);
+
+        await expect(writeFileContent('/test/file.txt', 'new content'))
+          .rejects.toThrow('ENOSPC');
+
+        expect(mockFs.unlink).toHaveBeenCalledWith(
+          expect.stringMatching(/\/test\/file\.txt\.[a-f0-9]+\.tmp$/)
+        );
+      });
+
+      it('cleans up temp file and re-throws when temp write fails', async () => {
+        const eexistError = new Error('EEXIST') as NodeJS.ErrnoException;
+        eexistError.code = 'EEXIST';
+        const enospcError = new Error('ENOSPC') as NodeJS.ErrnoException;
+        enospcError.code = 'ENOSPC';
+
+        mockFs.writeFile
+          .mockRejectedValueOnce(eexistError)
+          .mockRejectedValueOnce(enospcError);
+        mockFs.unlink.mockResolvedValue(undefined);
+
+        await expect(writeFileContent('/test/file.txt', 'new content'))
+          .rejects.toThrow('ENOSPC');
+
+        expect(mockFs.unlink).toHaveBeenCalledWith(
+          expect.stringMatching(/\/test\/file\.txt\.[a-f0-9]+\.tmp$/)
+        );
+      });
     });
 
   });
@@ -663,6 +705,24 @@ describe('Lib Functions', () => {
         );
       });
 
+      it('cleans up temp file and re-throws when temp write fails during file edit', async () => {
+        const enospcError = new Error('ENOSPC') as NodeJS.ErrnoException;
+        enospcError.code = 'ENOSPC';
+
+        mockFs.readFile.mockResolvedValue('line1\nline2\nline3\n');
+        mockFs.writeFile.mockRejectedValueOnce(enospcError);
+        mockFs.unlink.mockResolvedValue(undefined);
+
+        const edits = [{ oldText: 'line2', newText: 'modified line2' }];
+
+        await expect(applyFileEdits('/test/file.txt', edits, false))
+          .rejects.toThrow('ENOSPC');
+
+        expect(mockFs.unlink).toHaveBeenCalledWith(
+          expect.stringMatching(/\/test\/file\.txt\.[a-f0-9]+\.tmp$/)
+        );
+      });
+
       it('handles CRLF line endings in file content', async () => {
         mockFs.readFile.mockResolvedValue('line1\r\nline2\r\nline3\r\n');
 

src/filesystem/lib.ts

@@ -159,23 +159,28 @@ export async function validatePath(requestedPath: string): Promise<string> {
  * @param tempPath  Path to the temporary file that contains the new content.
  * @param targetPath  Path to the destination file to be replaced.
  */
+async function cleanupTempFile(tempPath: string): Promise<void> {
+  try {
+    await fs.unlink(tempPath);
+  } catch {}
+}
+
 async function replaceFileFromTemp(tempPath: string, targetPath: string): Promise<void> {
   try {
     await fs.rename(tempPath, targetPath);
   } catch (renameError) {
     if ((renameError as NodeJS.ErrnoException).code === 'EPERM') {
       // Fallback: copy then best-effort cleanup
-      await fs.cp(tempPath, targetPath, { force: true });
       try {
-        await fs.unlink(tempPath);
-      } catch {
-        // Best-effort cleanup; target was already written successfully
+        await fs.cp(tempPath, targetPath, { force: true });
+      } catch (copyError) {
+        await cleanupTempFile(tempPath);
+        throw copyError;
       }
+      await cleanupTempFile(tempPath);
     } else {
       // For non-EPERM errors, clean up the temp file and re-throw
-      try {
-        await fs.unlink(tempPath);
-      } catch {}
+      await cleanupTempFile(tempPath);
       throw renameError;
     }
   }
@@ -210,8 +215,13 @@ export async function writeFileContent(filePath: string, content: string): Promi
       // could be created between validation and write. Rename operations
       // replace the target file atomically and don't follow symlinks.
       const tempPath = `${filePath}.${randomBytes(16).toString('hex')}.tmp`;
-      await fs.writeFile(tempPath, content, 'utf-8');
-      await replaceFileFromTemp(tempPath, filePath);
+      try {
+        await fs.writeFile(tempPath, content, 'utf-8');
+        await replaceFileFromTemp(tempPath, filePath);
+      } catch (tempWriteError) {
+        await cleanupTempFile(tempPath);
+        throw tempWriteError;
+      }
     } else {
       throw error;
     }
@@ -301,8 +311,13 @@ export async function applyFileEdits(
     // could be created between validation and write. Rename operations
     // replace the target file atomically and don't follow symlinks.
     const tempPath = `${filePath}.${randomBytes(16).toString('hex')}.tmp`;
-    await fs.writeFile(tempPath, modifiedContent, 'utf-8');
-    await replaceFileFromTemp(tempPath, filePath);
+    try {
+      await fs.writeFile(tempPath, modifiedContent, 'utf-8');
+      await replaceFileFromTemp(tempPath, filePath);
+    } catch (writeError) {
+      await cleanupTempFile(tempPath);
+      throw writeError;
+    }
   }
 
   return formattedDiff;