test(project-files): pin upload cancellation during provenance and new-chat tab order

Author: waleedlatif1

apps/sim/lib/mothership/chat/project-file-context.integration.ts

@@ -24,6 +24,7 @@ import { createEvent } from '@/lib/mothership/request/session/event'
 import { encodeSSEEnvelope } from '@/lib/mothership/request/session/sse'
 import { persistResourceEffect } from '@/lib/mothership/resources/persist-effect'
 import { persistChatResources } from '@/lib/mothership/resources/persistence'
+import { createSearchResource } from '@/lib/mothership/resources/search'
 import { type MothershipResource, sanitizeChatResources } from '@/lib/mothership/resources/types'
 import { executeTool, registerHandler } from '@/lib/mothership/tool-executor/executor'
 import { createServerToolHandler } from '@/lib/mothership/tools/registry/server-tool-adapter'
@@ -750,6 +751,40 @@ describe('open tabs that no longer resolve', () => {
       expect(stored?.resources).toEqual([])
     }
   )
+
+  identityCheck(
+    'persists new-chat tabs in the order the user has them, not the order they resolve',
+    async () => {
+      const f = await fixture()
+      const fileId = await insertWorkspaceFile(f, 'First.md')
+      /** The search tab resolves synchronously, so it finishes before the file tab's lookups. */
+      const search = createSearchResource({
+        query: 'notes',
+        scope: { kind: 'workspace', workspaceId: f.workspaceId },
+      })
+      try {
+        await resolveResourceAttachmentContexts({
+          resourceAttachments: [{ type: 'file', id: fileId, title: 'First.md' }, search],
+          userId: f.userId,
+          workspaceId: f.workspaceId,
+          chatId: f.chatId,
+          requestMode: 'agent',
+          persistResources: true,
+          requestId: generateId(),
+        })
+        const [stored] = await db
+          .select({ resources: copilotChats.resources })
+          .from(copilotChats)
+          .where(eq(copilotChats.id, f.chatId))
+        expect((stored?.resources as MothershipResource[]).map((resource) => resource.id)).toEqual([
+          fileId,
+          search.id,
+        ])
+      } finally {
+        await db.delete(workspaceFiles).where(eq(workspaceFiles.id, fileId))
+      }
+    }
+  )
 })
 
 describe('legacy browser file address compatibility', () => {

apps/sim/lib/projects/files/__integration__/uploads.integration.ts

@@ -669,9 +669,11 @@ function workbench(f: Awaited<ReturnType<typeof fixture>>, bytes: Buffer) {
 
 async function privateUploadTransport(
   f: Awaited<ReturnType<typeof fixture>>,
-  uploadProvenance: () => WorkspaceFileSecretProvenance
+  uploadProvenance: () => WorkspaceFileSecretProvenance,
+  signal?: AbortSignal
 ) {
   const context = {
+    signal,
     userId: f.editorId,
     workspaceId: f.workspaceId,
     toolCallId: generateId(),
@@ -885,6 +887,45 @@ describe.skipIf(!redisUrl)('private Project upload transport', () => {
       expect(current.metadata.projectFileSecretProvenance).toMatchObject({ pending: true })
     }
   )
+
+  for (const signalOwner of ['request', 'invocation'] as const) {
+    check(
+      `private Project upload never registers a file when the ${signalOwner} is cancelled while its provenance resolves`,
+      async () => {
+        const f = await fixture()
+        const bytes = Buffer.from('cancelled upload')
+        const controller = new AbortController()
+        /** Resolves cleanly after the abort, so only a recheck before completion can stop it. */
+        const cancelling = () => {
+          controller.abort(new Error('cancelled during upload provenance'))
+          return { status: 'exact' as const, entries: [] }
+        }
+        const transport = await privateUploadTransport(
+          f,
+          cancelling,
+          signalOwner === 'invocation' ? controller.signal : undefined
+        )
+        const { session } = await createPrivateUpload(transport, f.projectId, bytes)
+        await put(session, bytes)
+        await expect(
+          transport(
+            `http://localhost:3000/api/v2/projects/${f.projectId}/files/uploads/${session.id}/complete`,
+            {
+              method: 'POST',
+              headers: { 'upload-token': session.uploadToken },
+              signal: signalOwner === 'request' ? controller.signal : undefined,
+            }
+          )
+        ).rejects.toThrow('cancelled during upload provenance')
+        const current = await sessions.verifyUploadSessionToken(session.uploadToken)
+        expect(current.completedFileId).toBeNull()
+        expect(
+          await db.select().from(workspaceFiles).where(eq(workspaceFiles.projectId, f.projectId))
+        ).toEqual([])
+        expect(await usage(f.organizationId)).toBe(0)
+      }
+    )
+  }
 })
 
 afterAll(async () => {