fix(chat): release-audit follow-ups for Project file tabs and sandbox copy parsing

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-resource-event.test.ts

@@ -469,6 +469,22 @@ describe('organization resource stream', () => {
     expect(workspace.removeResource).not.toHaveBeenCalled()
     expect(mocks.invalidateResourceQueries).not.toHaveBeenCalled()
   })
+
+  it('opens a Project file tab, which names no workspace, in an organization chat', () => {
+    const org = makeStreamLoopDeps({ workspaceId: undefined })
+    const projectFile = {
+      type: 'file' as const,
+      id: 'file-1',
+      title: 'context.md',
+      owner: { entityType: 'project' as const, entityId: 'project-1' },
+    }
+    handleResourceEvent({ deps: org } as StreamLoopContext, {
+      ...removeEvent('file', 'file-1'),
+      payload: { op: 'upsert', resource: projectFile },
+    })
+    expect(org.addResource).toHaveBeenCalledWith(projectFile)
+    expect(mocks.invalidateResourceQueries).not.toHaveBeenCalled()
+  })
 })
 
 describe('owner-addressed effects on a legacy tab', () => {

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-resource-event.ts

@@ -194,12 +194,19 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
   if (owner?.entityType === 'project' && payload.resource.type === 'file' && payload.resource.id)
     invalidateProjectFileQueries(queryClient, owner.entityId, payload.resource.id)
   const workspaceId = payload.resource.workspaceId ?? chatWorkspaceId
-  if (!workspaceId || (chatWorkspaceId && workspaceId !== chatWorkspaceId)) return
+  /** A Project file names no workspace, so an organization chat has none to check it against. */
+  if (
+    workspaceId
+      ? chatWorkspaceId && workspaceId !== chatWorkspaceId
+      : owner?.entityType !== 'project'
+  )
+    return
   // Browser and terminal tabs are projected from the desktop app's live
   // lists, never from the stream; older servers announced them as resources.
   if (payload.resource.type === 'browser' || payload.resource.type === 'terminal') return
   const resourceType = payload.resource.type
-  invalidateResourceQueries(queryClient, workspaceId, resourceType, payload.resource.id)
+  if (workspaceId)
+    invalidateResourceQueries(queryClient, workspaceId, resourceType, payload.resource.id)
   if (resourceType === 'workflow' && payload.op !== 'remove' && payload.resource.id) {
     notifyWorkflowExternalUpdate(payload.resource.id)
   }
@@ -246,7 +253,7 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
       : undefined
   const resource: MothershipResource = {
     ...payload.resource,
-    ...(chatWorkspaceId ? {} : { workspaceId }),
+    ...(!chatWorkspaceId && workspaceId ? { workspaceId } : {}),
     type: payload.resource.type as MothershipResourceType,
     title:
       typeof payload.resource.title === 'string' ? payload.resource.title : payload.resource.id,
@@ -264,7 +271,7 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
         current === getChatResourceSelectionId(resource) ? null : current
       )
     } else removeResource(resource)
-    if (resourceType === 'workflow') {
+    if (resourceType === 'workflow' && workspaceId) {
       removeWorkflowFromActiveCache(queryClient, workspaceId, resource.id)
     }
     return
@@ -352,7 +359,7 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
     } else onResourceEvent?.(getChatResourceSelectionId(resource))
   }
 
-  if (resource.type === 'workflow') {
+  if (resource.type === 'workflow' && workspaceId) {
     ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
   }
 }

apps/sim/lib/mothership/resources/store.test.ts

@@ -0,0 +1,45 @@
+import { queueTableRows, resetDbChainMock } from '@sim/testing/mocks/database.mock'
+import { schemaMock } from '@sim/testing/mocks/schema.mock'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { changeStoredChatResources } from '@/lib/mothership/resources/store'
+import type { MothershipResource } from '@/lib/mothership/resources/types'
+
+const unscopedFile: MothershipResource = { type: 'file', id: 'file-1', title: 'notes.md' }
+const scopedFile: MothershipResource = { ...unscopedFile, workspaceId: 'ws' }
+const table: MothershipResource = { type: 'table', id: 'table-1', title: 'Accounts' }
+
+function storeWorkspaceChat(resources: MothershipResource[]) {
+  queueTableRows(schemaMock.copilotChats, [{ resources, workspaceId: 'ws' }])
+}
+
+describe('changeStoredChatResources reorder', () => {
+  beforeEach(() => {
+    resetDbChainMock()
+  })
+
+  it('keeps the reorder when a workspace chat holds a tab both unscoped and scoped', async () => {
+    storeWorkspaceChat([unscopedFile, scopedFile, table])
+
+    const reordered = await changeStoredChatResources('chat-1', {
+      kind: 'reorder',
+      resources: [table, unscopedFile, scopedFile],
+    })
+
+    expect(reordered.map((resource) => resource.type)).toEqual(['table', 'file'])
+  })
+
+  it('still rejects an order that drops or invents a resource', async () => {
+    storeWorkspaceChat([scopedFile, table])
+    await expect(
+      changeStoredChatResources('chat-1', { kind: 'reorder', resources: [table, table] })
+    ).rejects.toThrow('Reordered resources must match existing resources')
+
+    storeWorkspaceChat([scopedFile, table])
+    await expect(
+      changeStoredChatResources('chat-1', {
+        kind: 'reorder',
+        resources: [table, { ...unscopedFile, id: 'file-2' }],
+      })
+    ).rejects.toThrow('Reordered resources must match existing resources')
+  })
+})

apps/sim/lib/mothership/resources/store.ts

@@ -8,6 +8,7 @@ import {
   type MothershipResource,
   type MothershipResourceUpdate,
   mergeChatResource,
+  reorderStoredChatResources,
   sanitizeChatResources,
 } from '@/lib/mothership/resources/types'
 
@@ -112,25 +113,20 @@ export async function changeStoredChatResources(
         const incoming = sanitizeChatResources(
           change.resources.filter((resource) => resource.id !== 'streaming-file')
         )
-        const byKey = new Map(existing.map((resource) => [keyOf(resource), resource]))
         if (change.kind === 'reorder') {
-          const keys = incoming.map(keyOf)
-          if (
-            keys.length !== byKey.size ||
-            new Set(keys).size !== keys.length ||
-            keys.some((key) => !byKey.has(key))
-          ) {
+          const reordered = reorderStoredChatResources(
+            existing,
+            incoming,
+            chat.workspaceId ?? undefined
+          )
+          if (!reordered)
             throw new OrchestrationError(
               'validation',
               'Reordered resources must match existing resources'
             )
-          }
-          resources = keys.map((key) => {
-            const resource = byKey.get(key)
-            if (!resource) throw new OrchestrationError('validation', 'Resource order changed')
-            return resource
-          })
+          resources = reordered
         } else {
+          const byKey = new Map(existing.map((resource) => [keyOf(resource), resource]))
           for (const resource of incoming) {
             const key = keyOf(resource)
             const previous = byKey.get(key)

apps/sim/lib/mothership/tools/sandbox-resource-transport.test.ts

@@ -6,6 +6,7 @@ import {
 import { urlsMockFns } from '@sim/testing/mocks/urls.mock'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { copilotRequestPrincipal, isCopilotRequest } from '@/lib/api/server/routes/copilot-request'
+import { DEFAULT_MAX_JSON_BODY_BYTES } from '@/lib/api/server/validation'
 import {
   type ContentSource,
   noteContentDeliveryOperation,
@@ -465,3 +466,31 @@ it('validates a copy body itself once the lease negotiated the file-owner protoc
   expect(response.status).toBe(400)
   expect(fetcher).not.toHaveBeenCalled()
 })
+
+it('leaves an oversized copy body to the workspace route without reading it past the cap', async () => {
+  readScope.mockResolvedValue({ ...scope, fileOwnerProtocolVersion: undefined })
+  routeMatcher.mockReturnValue({ params: {}, load: async () => ({ POST: fetcher }) })
+  fetcher.mockResolvedValue(Response.json({ error: 'Request body is too large' }, { status: 413 }))
+  const projectCopy = new TextEncoder().encode(
+    JSON.stringify({
+      source: { owner: workspaceOwner, fileIds: ['file'] },
+      destination: { owner: { entityType: 'project', entityId: 'project' } },
+    })
+  )
+  const padding = new Uint8Array(1024 * 1024).fill(0x20)
+  const paddingChunks = Math.ceil((2 * DEFAULT_MAX_JSON_BODY_BYTES) / padding.byteLength)
+  let pulledChunks = 0
+  const body = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (pulledChunks === 0) controller.enqueue(projectCopy)
+      else if (pulledChunks <= paddingChunks) controller.enqueue(padding)
+      else controller.close()
+      pulledChunks++
+    },
+  })
+  const init: RequestInit & { duplex: 'half' } = { method: 'POST', body, duplex: 'half' }
+  const response = await proxySandboxResourceRequest(request('/api/v2/files/copy', init), token)
+  expect(response.status).toBe(413)
+  expect(fetcher).toHaveBeenCalledTimes(1)
+  expect(pulledChunks).toBeLessThan(paddingChunks)
+})

apps/sim/lib/mothership/tools/sandbox-resource-transport.ts

@@ -1,10 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { generateId } from '@sim/utils/id'
 import { NextRequest } from 'next/server'
-import { fileCopyInputSchema } from '@/lib/api/contracts/file-copy-input'
 import { v2CopyFileItemsContract } from '@/lib/api/contracts/v2/file-copy'
 import { markCopilotRequest } from '@/lib/api/server/routes/copilot-request'
 import { matchV2Route } from '@/lib/api/server/routes/in-process-transport'
+import { V2_PARSE_DEFAULTS } from '@/lib/api/server/routes/v2-json-route'
+import { parseRequest } from '@/lib/api/server/validation'
 import { withWorkspaceInvocationScope } from '@/lib/core/application/workspace-invocation-scope'
 import { asOrchestrationError, statusForOrchestrationError } from '@/lib/core/orchestration/types'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
@@ -203,18 +204,21 @@ async function proxyAuthorizedSandboxRequest(
   })
 }
 
-/** A valid copy naming a non-workspace source or destination needs the file-owner protocol. */
+/**
+ * A valid copy naming a non-workspace source or destination needs the file-owner protocol. Parsed
+ * as the copy route parses it, under the same body cap: an oversized or invalid body stays on the
+ * workspace route, which returns its own 413 or 400.
+ */
 async function copiesBeyondWorkspaces(request: Request): Promise<boolean> {
-  let body: unknown
-  try {
-    body = await request.clone().json()
-  } catch {
-    return false
-  }
-  const parsed = fileCopyInputSchema.safeParse(body)
+  const parsed = await parseRequest(
+    v2CopyFileItemsContract,
+    new NextRequest(request.clone()),
+    {},
+    V2_PARSE_DEFAULTS
+  )
   return (
     parsed.success &&
-    (parsed.data.source.owner.entityType !== 'workspace' ||
-      parsed.data.destination.owner.entityType !== 'workspace')
+    (parsed.data.body.source.owner.entityType !== 'workspace' ||
+      parsed.data.body.destination.owner.entityType !== 'workspace')
   )
 }