fix(files): surface download aborts and sync the copilot artifact bucket to workers

Author: icecrasher321

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

@@ -0,0 +1,114 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockDownloadFile } = vi.hoisted(() => ({
+  mockDownloadFile: vi.fn(),
+}))
+
+vi.mock('@/lib/billing/storage', () => ({
+  decrementStorageUsageForBillingContextInTx: vi.fn(),
+  incrementStorageUsageForBillingContextInTx: vi.fn(),
+  maybeNotifyStorageLimitForBillingContext: vi.fn(),
+  resolveStorageBillingContext: vi.fn(),
+}))
+
+vi.mock('@/lib/uploads', () => ({
+  getServePathPrefix: vi.fn(() => '/api/files/serve/s3/'),
+}))
+
+vi.mock('@/lib/uploads/core/storage-service', () => ({
+  deleteFile: vi.fn(),
+  downloadFile: mockDownloadFile,
+  hasCloudStorage: vi.fn(() => false),
+  headObject: vi.fn(),
+  uploadFile: vi.fn(),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-folder-manager', () => ({
+  assertWorkspaceFileFolderTarget: vi.fn(async () => null),
+  buildWorkspaceFileFolderPathMap: vi.fn(() => new Map()),
+  fileNameExistsInWorkspaceFolder: vi.fn(async () => false),
+  findWorkspaceFileFolderIdByPath: vi.fn(),
+  getWorkspaceFileFolderPath: vi.fn(),
+  listWorkspaceFileFolders: vi.fn(async () => []),
+  normalizeWorkspaceFileItemName: vi.fn((name: string) => name),
+  resolveWorkspaceFileFolderTarget: vi.fn(async () => null),
+}))
+
+import { assertKnownSizeWithinLimit, isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
+import {
+  fetchWorkspaceFileBuffer,
+  type WorkspaceFileRecord,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const FILE: WorkspaceFileRecord = {
+  id: 'file-1',
+  workspaceId: 'workspace-1',
+  name: 'notes.txt',
+  key: 'workspace/workspace-1/notes.txt',
+  path: '/api/files/serve/workspace/workspace-1/notes.txt',
+  size: 5,
+  type: 'text/plain',
+  uploadedBy: 'user-1',
+  uploadedAt: new Date('2026-09-01T00:00:00.000Z'),
+  updatedAt: new Date('2026-09-01T00:00:00.000Z'),
+}
+
+function sizeLimitError(): unknown {
+  try {
+    assertKnownSizeWithinLimit(2, 1, 'test')
+  } catch (error) {
+    return error
+  }
+  throw new Error('assertKnownSizeWithinLimit did not throw')
+}
+
+describe('fetchWorkspaceFileBuffer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('forwards the byte ceiling and the cancellation signal to storage', async () => {
+    const bytes = Buffer.from('hello')
+    mockDownloadFile.mockResolvedValue(bytes)
+    const signal = new AbortController().signal
+
+    await expect(fetchWorkspaceFileBuffer(FILE, { maxBytes: 10, signal })).resolves.toBe(bytes)
+    expect(mockDownloadFile).toHaveBeenCalledWith({
+      key: FILE.key,
+      context: 'workspace',
+      maxBytes: 10,
+      signal,
+    })
+  })
+
+  it('surfaces a cancelled read as the abort rather than a download failure', async () => {
+    const controller = new AbortController()
+    mockDownloadFile.mockImplementation(async () => {
+      controller.abort()
+      throw new Error('read interrupted')
+    })
+
+    await expect(
+      fetchWorkspaceFileBuffer(FILE, { maxBytes: 10, signal: controller.signal })
+    ).rejects.toMatchObject({ name: 'AbortError' })
+  })
+
+  it('rethrows a byte-ceiling breach unwrapped', async () => {
+    mockDownloadFile.mockRejectedValue(sizeLimitError())
+
+    await expect(fetchWorkspaceFileBuffer(FILE, { maxBytes: 10 })).rejects.toSatisfy(
+      isPayloadSizeLimitError
+    )
+  })
+
+  it('wraps other transport failures', async () => {
+    mockDownloadFile.mockRejectedValue(new Error('socket hang up'))
+
+    await expect(fetchWorkspaceFileBuffer(FILE, { maxBytes: 10 })).rejects.toThrow(
+      'Failed to download file: socket hang up'
+    )
+  })
+})

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

@@ -1694,6 +1694,9 @@ export async function fetchWorkspaceFileBuffer(
     )
     return buffer
   } catch (error) {
+    // A cancelled read is not a download failure: surface the abort itself so the
+    // caller sees cancellation, not a transport error it might retry or record.
+    options.signal?.throwIfAborted()
     logger.error(`Failed to download workspace file ${fileRecord.name}:`, error)
     // Rethrow a `maxBytes` breach unwrapped: callers distinguish "too large" from a
     // transport failure to answer with their own placeholder, and re-wrapping it in a

apps/sim/trigger.config.ts

@@ -33,9 +33,11 @@ if (grafanaConfigured && !grafanaFullyConfigured) {
  * sandbox's artifact store or the isolated-vm fallback. The app authors
  * documents for whichever compiler it sees, so a worker missing the doc
  * template falls back to isolated-vm and tries to run Python or Node-style
- * sources as sandbox JavaScript. The values still have to exist in the
- * Trigger.dev environment; syncing only keeps the worker's view of them
- * aligned with the app's.
+ * sources as sandbox JavaScript. Reading a generated document under the doc
+ * sandbox means loading its compiled artifact from the copilot storage
+ * context, so that bucket has to be visible to the run as well. The values
+ * still have to exist in the Trigger.dev environment; syncing only keeps the
+ * worker's view of them aligned with the app's.
  */
 const FUNCTION_EXECUTION_ENV = [
   { name: 'REDIS_URL', secret: true },
@@ -49,6 +51,9 @@ const FUNCTION_EXECUTION_ENV = [
   { name: 'DAYTONA_API_KEY', secret: true },
   { name: 'DAYTONA_FUNCTION_SNAPSHOT_ID', secret: false },
   { name: 'DAYTONA_DOC_SNAPSHOT_ID', secret: false },
+  { name: 'S3_COPILOT_BUCKET_NAME', secret: false },
+  { name: 'AZURE_STORAGE_COPILOT_CONTAINER_NAME', secret: false },
+  { name: 'GCS_COPILOT_BUCKET_NAME', secret: false },
 ] as const
 
 function getFunctionExecutionEnvVars() {