fix(uploads): tolerate transient storage probes and reject unowned keys with 403

Follow-ups from a backward-compatibility audit of the attachment-key hardening.

The existence probe is hygiene, not authorization — the key-format and
no-prior-record guards already carry that, and a binding to a nonexistent
object grants nothing readable. But `headObject` rethrows non-404 provider
errors, so a transient 5xx or throttle would drop a legitimate attachment.
Only a definitive not-found now rejects; a thrown error logs and proceeds on
the ownership guards. This path is reached solely by >50MB multipart uploads,
the one flow that persists no metadata row at upload time.

The stage route mapped an ownership rejection to a 500. It is a client error;
return 403 instead.

Author: waleedlatif1

apps/sim/app/api/mothership/local-files/stage/route.ts

@@ -13,7 +13,10 @@ import {
 } from '@/lib/copilot/request/http'
 import { encodeVfsSegment } from '@/lib/copilot/vfs/path-utils'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { trackChatUpload } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import {
+  trackChatUpload,
+  WorkspaceFileKeyOwnershipError,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('StageLocalFileUploadAPI')
@@ -95,6 +98,13 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       uploadPath: `uploads/${encodeVfsSegment(displayName)}`,
     })
   } catch (error) {
+    if (error instanceof WorkspaceFileKeyOwnershipError) {
+      // The caller supplied a key they may not bind — a client error, not ours.
+      logger.warn('Rejected chat upload staging for an unowned storage key', {
+        error: error.message,
+      })
+      return NextResponse.json({ error: 'Storage key is not available' }, { status: 403 })
+    }
     logger.error('Failed to stage local file upload', error)
     return createInternalServerErrorResponse('Failed to stage local file upload')
   }

apps/sim/lib/copilot/chat/payload.ts

@@ -338,6 +338,8 @@ export async function buildCopilotRequestPayload(
   // upload routes that issue these keys already require — reaching the chat
   // endpoint with `read` must not confer a file-write capability.
   const uploadContexts: Array<{ type: string; content: string; tag?: string; path?: string }> = []
+  // `PermissionType` is exactly read | write | admin, so this covers the whole
+  // write-or-better half of the ordering.
   const canWriteWorkspaceFiles =
     params.userPermission === 'write' || params.userPermission === 'admin'
   if (chatId && params.workspaceId && fileAttachments && fileAttachments.length > 0) {

apps/sim/lib/uploads/contexts/workspace/track-chat-upload.test.ts

@@ -412,6 +412,31 @@ describe('trackChatUpload', () => {
       expect(dbChainMockFns.values).not.toHaveBeenCalled()
     })
 
+    /**
+     * The probe is hygiene, not authorization — a provider 5xx must not drop a
+     * legitimate >50MB multipart upload, which is the only path that reaches it.
+     * Only a definitive not-found (`null`) rejects.
+     */
+    it('proceeds when the storage existence probe throws a transient error', async () => {
+      queueOwnershipLookup([])
+      mockHeadObject.mockRejectedValueOnce(new Error('503 SlowDown'))
+
+      const result = await trackChatUpload(
+        WORKSPACE_ID,
+        USER_ID,
+        CHAT_ID,
+        S3_KEY,
+        'image.png',
+        'image/png',
+        1024
+      )
+
+      expect(result).toEqual({ displayName: 'image.png' })
+      expect(dbChainMockFns.values).toHaveBeenCalledWith(
+        expect.objectContaining({ key: S3_KEY, context: 'mothership' })
+      )
+    })
+
     /** Local-storage deployments have no headObject to consult; ownership still gates. */
     it('skips the storage existence probe when cloud storage is not configured', async () => {
       mockHasCloudStorage.mockReturnValue(false)

apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts

@@ -689,7 +689,21 @@ export async function trackChatUpload(
   const claimable = await resolveClaimableChatUploadRow(workspaceId, userId, s3Key)
 
   if (claimable.kind === 'insert' && hasCloudStorage()) {
-    const head = await headObject(s3Key, 'workspace')
+    // Hygiene only — the format and no-prior-record guards above already carry
+    // authorization, and a binding to a nonexistent object grants nothing
+    // readable. So reject only on a definitive not-found (`null`); a provider
+    // 5xx/throttle throws, and failing the attachment on that would drop a
+    // legitimate >50MB multipart upload (the sole path reaching this branch).
+    let head: Awaited<ReturnType<typeof headObject>> = null
+    try {
+      head = await headObject(s3Key, 'workspace')
+    } catch (error) {
+      logger.warn('Chat upload existence probe failed; proceeding on the ownership guards', {
+        key: s3Key,
+        error: getErrorMessage(error),
+      })
+      head = { size }
+    }
     if (!head) {
       throw new WorkspaceFileKeyOwnershipError(s3Key)
     }