fix(files): keep an overwrite create on its exact path

Author: TheodoreSpeaks

apps/sim/lib/internal/file/operations.test.ts

@@ -164,6 +164,7 @@ vi.mock('@/app/api/files/authorization', () => ({
 
 import { fileManageBodySchema } from '@/lib/api/contracts/tools/file'
 import { executeFileManageOperation } from '@/lib/internal/file/operations'
+import { FileConflictError } from '@/lib/uploads/contexts/workspace'
 import { createWorkspaceFileDelegatedPrincipal } from '@/lib/workspace-files/application/delegated-principal'
 
 async function POST(request: Request): Promise<Response> {
@@ -676,10 +677,29 @@ describe('file manage operations', () => {
       Buffer.from('fresh'),
       'report.txt',
       'text/plain',
-      expect.objectContaining({ exactName: false, folderId: null })
+      // Exact, so a path created by a concurrent write conflicts instead of being suffixed.
+      expect.objectContaining({ exactName: true, folderId: null })
     )
   })
 
+  it('surfaces a conflict when a concurrent write claims the overwrite path', async () => {
+    mockResolveWorkspaceFileReference.mockResolvedValue(null)
+    mockUploadWorkspaceFile.mockRejectedValue(new FileConflictError('report.txt'))
+
+    const response = await POST(
+      createMockRequest('POST', {
+        operation: 'write',
+        workspaceId: 'workspace-1',
+        fileName: 'report.txt',
+        content: 'fresh',
+        overwrite: true,
+      })
+    )
+
+    expect(response.status).toBe(409)
+    await expect(response.json()).resolves.toMatchObject({ success: false })
+  })
+
   it('never overwrites a same-named file resolved outside the target folder', async () => {
     mockResolveWorkspaceFileReference.mockResolvedValue({
       ...workspaceFile('report'),

apps/sim/lib/internal/file/operations.ts

@@ -974,7 +974,10 @@ export async function executeFileManageOperation(
             content: sourceContent,
             encoding: sourceEncoding,
             folderId,
-            exactName: false,
+            // An overwrite that found no target must land on the exact path or fail. Suffixing
+            // would silently satisfy the request at the wrong name when a concurrent write
+            // created that path in between; exactName surfaces the race as a conflict instead.
+            exactName: Boolean(overwrite),
             ...(writeProvenance ? { secretProvenance: writeProvenance } : {}),
           },
         })