fix(mothership): keep chat forks outside workspace storage billing

Preserve the product invariant that Mothership chat files are not charged as workspace file storage after the billing storage merge.

Author: icecrasher321

apps/sim/app/api/mothership/chats/[chatId]/fork/route.test.ts

@@ -8,7 +8,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 const {
   mockTransaction,
   mockSelectRows,
-  mockCheckStorageQuota,
   mockFilterForkableChatFiles,
   mockListForkableChatFiles,
   mockPlanChatFileCopies,
@@ -24,7 +23,6 @@ const {
 } = vi.hoisted(() => ({
   mockTransaction: vi.fn(),
   mockSelectRows: vi.fn(),
-  mockCheckStorageQuota: vi.fn(),
   // Real (pure) cut semantics so tests drive selection through row.messageId:
   // rows with a NULL/undefined messageId are kept in every fork.
   mockFilterForkableChatFiles: vi.fn(
@@ -89,10 +87,6 @@ vi.mock('@/lib/copilot/resources/persistence', () => ({
 
 vi.mock('@/lib/copilot/request/http', () => copilotHttpMock)
 
-vi.mock('@/lib/billing/storage', () => ({
-  checkStorageQuota: mockCheckStorageQuota,
-}))
-
 vi.mock('@/lib/copilot/chat/fork-chat-files', () => ({
   filterForkableChatFiles: mockFilterForkableChatFiles,
   listForkableChatFiles: mockListForkableChatFiles,
@@ -218,7 +212,6 @@ describe('POST /api/mothership/chats/[chatId]/fork', () => {
     })
     mockSelectRows.mockResolvedValue([parentRow])
     mockListForkableChatFiles.mockResolvedValue([])
-    mockCheckStorageQuota.mockResolvedValue({ allowed: true })
     mockLoadCopilotChatMessages.mockResolvedValue(threeMessages)
     mockPlanChatFileCopies.mockResolvedValue({
       idMap: new Map(),
@@ -316,42 +309,6 @@ describe('POST /api/mothership/chats/[chatId]/fork', () => {
     expect(appended[1].map((m: { id: string }) => m.id)).toEqual(['msg-1', 'msg-2'])
   })
 
-  it('fails up front with the quota error when copied bytes would exceed the limit', async () => {
-    mockListForkableChatFiles.mockResolvedValue([
-      { size: 600, workspaceId: 'ws-1' },
-      { size: 400, workspaceId: 'ws-1' },
-    ])
-    mockCheckStorageQuota.mockResolvedValue({ allowed: false, error: 'Storage limit exceeded' })
-
-    const res = await POST(createRequest('chat-1'), makeContext('chat-1'))
-
-    expect(res.status).toBe(400)
-    expect(mockCheckStorageQuota).toHaveBeenCalledWith('user-1', 1000)
-    expect(mockTransaction).not.toHaveBeenCalled()
-    expect(mockExecuteChatFileBlobCopies).not.toHaveBeenCalled()
-  })
-
-  it('excludes uncopyable rows (no workspaceId) from the quota sum', async () => {
-    // planChatFileCopies skips workspaceId-less legacy rows, so their bytes
-    // must not count against the gate.
-    mockListForkableChatFiles.mockResolvedValue([{ size: 600, workspaceId: 'ws-1' }, { size: 400 }])
-
-    const res = await POST(createRequest('chat-1'), makeContext('chat-1'))
-
-    expect(res.status).toBe(200)
-    expect(mockCheckStorageQuota).toHaveBeenCalledWith('user-1', 600)
-  })
-
-  it('skips the quota check entirely when no chat-owned rows are in the cut', async () => {
-    // The chat owns one file, but it was born after the fork point.
-    mockListForkableChatFiles.mockResolvedValue([
-      { id: 'wf_late', size: 500, context: 'mothership', messageId: 'msg-3' },
-    ])
-    const res = await POST(createRequest('chat-1'), makeContext('chat-1'))
-    expect(res.status).toBe(200)
-    expect(mockCheckStorageQuota).not.toHaveBeenCalled()
-  })
-
   it('forks the chat: copies kept uploads, rewrites references, clones agent state', async () => {
     const blobTasks = [
       {
@@ -378,17 +335,12 @@ describe('POST /api/mothership/chats/[chatId]/fork', () => {
     expect(body.success).toBe(true)
     expect(typeof body.id).toBe('string')
 
-    expect(mockCheckStorageQuota).toHaveBeenCalledWith('user-1', 100)
-
     // The real rewriter runs: the kept message's view-URL points at the copy.
     const appended = mockAppendCopilotChatMessages.mock.calls[0]
     expect(appended[0]).toBe(body.id)
     expect(appended[1][0].content).toBe(`See ![cat](/api/files/view/${NEW_FILE_ID})`)
 
-    expect(mockExecuteChatFileBlobCopies).toHaveBeenCalledWith(blobTasks, {
-      userId: 'user-1',
-      workspaceId: 'ws-1',
-    })
+    expect(mockExecuteChatFileBlobCopies).toHaveBeenCalledWith(blobTasks)
 
     const goCall = mockFetchGo.mock.calls[0]
     expect(goCall[0]).toBe('http://mothership.test/api/chats/fork')

apps/sim/app/api/mothership/chats/[chatId]/fork/route.ts

@@ -6,7 +6,6 @@ import { eq, inArray } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { forkMothershipChatContract } from '@/lib/api/contracts/mothership-chats'
 import { parseRequest } from '@/lib/api/server'
-import { checkStorageQuota } from '@/lib/billing/storage'
 import {
   executeChatFileBlobCopies,
   filterForkableChatFiles,
@@ -49,11 +48,11 @@ const logger = createLogger('ForkChatAPI')
  * at-or-before the fork point (a file travels iff the user message that
  * carried it is kept). Resources and copilot-side state are copied.
  *
- * Every copied file gets a fresh row id and storage key, bytes are physically
- * copied and counted against the storage quota, and every in-transcript file
- * reference is re-pointed at the copies so the new chat survives deletion of
- * the source chat. File resources whose chat-owned file was NOT copied
- * (uploads born after the cut) are dropped from the new chat's resources
+ * Every copied file gets a fresh row id and storage key, and every
+ * in-transcript file reference is re-pointed at the copies so the new chat
+ * survives deletion of the source chat. Mothership files remain excluded from
+ * workspace storage accounting. File resources whose chat-owned file was NOT
+ * copied (uploads born after the cut) are dropped from the new chat's resources
  * rather than left as ghosts pointing at the source chat's files.
  */
 export const POST = withRouteHandler(
@@ -111,19 +110,6 @@ export const POST = withRouteHandler(
         chatOwnedFiles,
         new Set(forkedMessages.map((m) => m.id))
       )
-      // Sum only rows the plan will actually copy — planChatFileCopies skips
-      // rows with no workspaceId, so counting their bytes could reject a fork
-      // whose real copies fit within quota.
-      const totalFileBytes = sourceFiles.reduce(
-        (sum, row) => (row.workspaceId ? sum + row.size : sum),
-        0
-      )
-      if (totalFileBytes > 0) {
-        const quotaCheck = await checkStorageQuota(userId, totalFileBytes)
-        if (!quotaCheck.allowed) {
-          return createBadRequestResponse(quotaCheck.error || 'Storage limit exceeded')
-        }
-      }
 
       // Resources are stored as a jsonb array on the chat row. They carry no
       // timestamps, so they can't be timeline-cut like messages — instead,
@@ -202,10 +188,7 @@ export const POST = withRouteHandler(
       }
       const newChat = result.row
 
-      const { copied, failed, failedCopyIds } = await executeChatFileBlobCopies(result.blobTasks, {
-        userId,
-        workspaceId: parent.workspaceId ?? undefined,
-      })
+      const { copied, failed, failedCopyIds } = await executeChatFileBlobCopies(result.blobTasks)
       if (failed > 0) {
         // A failed blob copy leaves a committed row with no bytes behind it.
         // Cleanly absent beats present-but-broken: hard-delete the dead rows

apps/sim/lib/copilot/chat/fork-chat-files.test.ts

@@ -3,14 +3,11 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGenerateKey, mockDownloadFile, mockUploadFile, mockIncrementStorageUsage } = vi.hoisted(
-  () => ({
-    mockGenerateKey: vi.fn(),
-    mockDownloadFile: vi.fn(),
-    mockUploadFile: vi.fn(),
-    mockIncrementStorageUsage: vi.fn(),
-  })
-)
+const { mockGenerateKey, mockDownloadFile, mockUploadFile } = vi.hoisted(() => ({
+  mockGenerateKey: vi.fn(),
+  mockDownloadFile: vi.fn(),
+  mockUploadFile: vi.fn(),
+}))
 
 vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
   generateWorkspaceFileKey: mockGenerateKey,
@@ -21,10 +18,6 @@ vi.mock('@/lib/uploads/core/storage-service', () => ({
   uploadFile: mockUploadFile,
 }))
 
-vi.mock('@/lib/billing/storage', () => ({
-  incrementStorageUsage: mockIncrementStorageUsage,
-}))
-
 import {
   executeChatFileBlobCopies,
   type ForkableChatFileRow,
@@ -141,14 +134,10 @@ describe('executeChatFileBlobCopies', () => {
     vi.clearAllMocks()
     mockDownloadFile.mockResolvedValue(Buffer.from('0123456789'))
     mockUploadFile.mockResolvedValue(undefined)
-    mockIncrementStorageUsage.mockResolvedValue(undefined)
   })
 
-  it('copies bytes to the new key and counts them against the storage quota', async () => {
-    const result = await executeChatFileBlobCopies([task], {
-      userId: 'user-1',
-      workspaceId: 'ws-1',
-    })
+  it('copies bytes to the new key without workspace storage accounting', async () => {
+    const result = await executeChatFileBlobCopies([task])
 
     expect(result).toEqual({ copied: 1, failed: 0, failedCopyIds: [] })
     expect(mockUploadFile).toHaveBeenCalledWith(
@@ -159,23 +148,18 @@ describe('executeChatFileBlobCopies', () => {
     )
     // No `metadata` in the upload call — passing it would insert a second row.
     expect(mockUploadFile.mock.calls[0][0].metadata).toBeUndefined()
-    expect(mockIncrementStorageUsage).toHaveBeenCalledWith('user-1', 10, 'ws-1')
   })
 
-  it('is best-effort: a failed download skips the file, counts nothing, and reports its copy id', async () => {
+  it('is best-effort: a failed download skips the file and reports its copy id', async () => {
     mockDownloadFile.mockRejectedValueOnce(new Error('blob missing'))
 
-    const result = await executeChatFileBlobCopies(
-      [task, { ...task, copyId: 'wf_copy2', targetKey: 'workspace/ws-1/3-cat.png' }],
-      {
-        userId: 'user-1',
-        workspaceId: 'ws-1',
-      }
-    )
+    const result = await executeChatFileBlobCopies([
+      task,
+      { ...task, copyId: 'wf_copy2', targetKey: 'workspace/ws-1/3-cat.png' },
+    ])
 
     // The first task's download failed — its copy id comes back for row cleanup.
     expect(result).toEqual({ copied: 1, failed: 1, failedCopyIds: ['wf_copy'] })
-    expect(mockIncrementStorageUsage).toHaveBeenCalledTimes(1)
   })
 
   it('copies every task even when the batch exceeds the concurrency bound', async () => {
@@ -185,7 +169,7 @@ describe('executeChatFileBlobCopies', () => {
       targetKey: `workspace/ws-1/${i}-cat.png`,
     }))
 
-    const result = await executeChatFileBlobCopies(tasks, { userId: 'user-1' })
+    const result = await executeChatFileBlobCopies(tasks)
 
     expect(result.copied).toBe(9)
     expect(mockUploadFile).toHaveBeenCalledTimes(9)

apps/sim/lib/copilot/chat/fork-chat-files.ts

@@ -3,7 +3,6 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateShortId } from '@sim/utils/id'
 import { and, eq, isNull } from 'drizzle-orm'
-import { incrementStorageUsage } from '@/lib/billing/storage'
 import { mapWithConcurrency } from '@/lib/core/utils/concurrency'
 import type { DbOrTx } from '@/lib/db/types'
 import { generateWorkspaceFileKey } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
@@ -156,15 +155,13 @@ export async function planChatFileCopies(params: {
  * missing) rather than failing the whole fork. Runs a bounded worker pool
  * ({@link CHAT_BLOB_COPY_CONCURRENCY}) — media-heavy chats must not pay 2N
  * serial storage round-trips, but unbounded fan-out would buffer every file
- * in memory at once. Each successfully copied file increments the
- * storage-usage counter by its actual byte length. Failed tasks' copy-row ids
- * are returned so the caller can delete the dead rows (row exists, blob
- * doesn't) instead of leaving them listed in the VFS and resources with
- * nothing behind them.
+ * in memory at once. Mothership files remain excluded from workspace storage
+ * accounting. Failed tasks' copy-row ids are returned so the caller can delete
+ * the dead rows (row exists, blob doesn't) instead of leaving them listed in
+ * the VFS and resources with nothing behind them.
  */
 export async function executeChatFileBlobCopies(
-  blobTasks: ChatBlobCopyTask[],
-  params: { userId: string; workspaceId?: string }
+  blobTasks: ChatBlobCopyTask[]
 ): Promise<{ copied: number; failed: number; failedCopyIds: string[] }> {
   let copied = 0
   const failedCopyIds: string[] = []
@@ -193,20 +190,6 @@ export async function executeChatFileBlobCopies(
         preserveKey: true,
       })
       copied += 1
-      try {
-        // Forked bytes COUNT against the storage quota, deliberately diverging
-        // from the workspace-fork copy path
-        // (lib/workspaces/fork/copy/copy-files.ts), which copies blobs without
-        // counting them. A chat fork stores a second physical copy of every
-        // kept upload, so the counter must reflect it. Do not "fix" this back
-        // to the workspace-fork precedent.
-        await incrementStorageUsage(params.userId, buffer.length, params.workspaceId)
-      } catch (error) {
-        logger.error('Failed to update storage tracking for forked chat file', {
-          targetKey: task.targetKey,
-          error: getErrorMessage(error),
-        })
-      }
     } catch (error) {
       failedCopyIds.push(task.copyId)
       logger.warn('Failed to copy chat file blob during fork', {