fix(files): harden Markdown PDF export

Author: Bill Leoutsakos

apps/sim/app/api/files/export/[id]/markdown-pdf.test.ts

@@ -40,7 +40,7 @@ Smart quotes “work”, Greek Ω stays readable, and unsupported emoji 🚀 fal
 const exported = true
 \`\`\`
 
-![Embedded image](/api/files/view/image-1)
+![Embedded image](/workspace/ws-1/files/image-1)
 
 ${repeatedParagraphs}`
 
@@ -57,4 +57,19 @@ ${repeatedParagraphs}`
     expect(document.getTitle()).toBe('Export title')
     expect(document.getPageCount()).toBeGreaterThan(1)
   })
+
+  it('falls back instead of decoding an image above the pixel ceiling', async () => {
+    const oversizedSvg = Buffer.from(
+      '<svg xmlns="http://www.w3.org/2000/svg" width="20000" height="20000"><rect width="100%" height="100%" fill="red"/></svg>'
+    )
+
+    const buffer = await renderMarkdownPdf({
+      markdown: '![Too large](/api/files/view/image-1)',
+      title: 'Bounded image',
+      images: new Map([['image-1', oversizedSvg]]),
+    })
+
+    expect(buffer.subarray(0, 4).toString()).toBe('%PDF')
+    expect((await PDFDocument.load(buffer)).getPageCount()).toBe(1)
+  })
 })

apps/sim/app/api/files/export/[id]/markdown-pdf.tsx

@@ -14,6 +14,7 @@ import {
 } from '@react-pdf/renderer'
 import { marked, type Token, type Tokens } from 'marked'
 import sharp from 'sharp'
+import { extractEmbeddedFileRef } from '@/lib/uploads/utils/embedded-image-ref'
 
 type PdfImage = { data: Buffer; format: 'png' }
 
@@ -25,6 +26,18 @@ const FONT_DIR = join(process.cwd(), 'public', 'brand', 'fonts')
 const GEIST_REGULAR = join(FONT_DIR, 'Geist-Regular.ttf')
 const GEIST_MEDIUM = join(FONT_DIR, 'Geist-Medium.ttf')
 
+/**
+ * PDF images never render wider than the A4 content box, so retaining camera-resolution
+ * rasters only increases Sharp and React PDF work. The dimension matches the app's existing
+ * inline-image preparation ceiling; the aggregate budgets bound work across a document.
+ */
+const MAX_PDF_IMAGE_DIMENSION = 1568
+const MAX_PDF_IMAGE_INPUT_PIXELS = 268_402_689
+const MAX_PDF_TOTAL_INPUT_PIXELS = 268_402_689
+const MAX_PDF_TOTAL_OUTPUT_PIXELS = 25_000_000
+const MAX_PDF_IMAGE_BYTES = 12 * 1024 * 1024
+const MAX_PDF_TOTAL_IMAGE_BYTES = 32 * 1024 * 1024
+
 Font.register({
   family: 'Geist',
   fonts: [
@@ -148,15 +161,8 @@ function safeLink(href: string): string | undefined {
 }
 
 function embeddedImageId(href: string): string | undefined {
-  const match =
-    href.match(/\/api\/files\/view\/([^/?#]+)/) ??
-    href.match(/\/workspace\/[^/]+\/files\/([^/?#]+)/)
-  if (!match?.[1]) return undefined
-  try {
-    return decodeURIComponent(match[1])
-  } catch {
-    return match[1]
-  }
+  const ref = extractEmbeddedFileRef(href)
+  return ref && 'fileId' in ref ? ref.fileId : undefined
 }
 
 function renderInline(tokens: Token[], keyPrefix: string): ReactNode[] {
@@ -423,9 +429,55 @@ async function normalizeImages(
   images: ReadonlyMap<string, Buffer>
 ): Promise<Map<string, PdfImage>> {
   const normalized = new Map<string, PdfImage>()
+  let totalInputPixels = 0
+  let totalOutputPixels = 0
+  let totalImageBytes = 0
+
   for (const [id, buffer] of images) {
     try {
-      normalized.set(id, { data: await sharp(buffer).rotate().png().toBuffer(), format: 'png' })
+      const pipeline = sharp(buffer, { limitInputPixels: MAX_PDF_IMAGE_INPUT_PIXELS })
+      const metadata = await pipeline.metadata()
+      if (!metadata.width || !metadata.height) continue
+
+      const inputPixels = metadata.width * metadata.height
+      if (
+        !Number.isSafeInteger(inputPixels) ||
+        totalInputPixels + inputPixels > MAX_PDF_TOTAL_INPUT_PIXELS
+      ) {
+        continue
+      }
+      totalInputPixels += inputPixels
+
+      const scale = Math.min(
+        1,
+        MAX_PDF_IMAGE_DIMENSION / metadata.width,
+        MAX_PDF_IMAGE_DIMENSION / metadata.height
+      )
+      const outputWidth = Math.max(1, Math.round(metadata.width * scale))
+      const outputHeight = Math.max(1, Math.round(metadata.height * scale))
+      const outputPixels = outputWidth * outputHeight
+      if (totalOutputPixels + outputPixels > MAX_PDF_TOTAL_OUTPUT_PIXELS) continue
+
+      const data = await pipeline
+        .rotate()
+        .resize({
+          width: MAX_PDF_IMAGE_DIMENSION,
+          height: MAX_PDF_IMAGE_DIMENSION,
+          fit: 'inside',
+          withoutEnlargement: true,
+        })
+        .png()
+        .toBuffer()
+      if (
+        data.length > MAX_PDF_IMAGE_BYTES ||
+        totalImageBytes + data.length > MAX_PDF_TOTAL_IMAGE_BYTES
+      ) {
+        continue
+      }
+
+      totalOutputPixels += outputPixels
+      totalImageBytes += data.length
+      normalized.set(id, { data, format: 'png' })
     } catch {
       // Keep the PDF usable when an otherwise downloadable attachment is not a renderable image.
     }

apps/sim/app/api/files/export/[id]/route.test.ts

@@ -13,13 +13,19 @@ const {
   mockDownloadFile,
   mockExtractEmbeddedImageIds,
   mockRenderMarkdownPdf,
+  mockEnforceUserRateLimit,
+  mockRecordAudit,
+  mockCaptureServerEvent,
 } = vi.hoisted(() => ({
   mockCheckAuth: vi.fn(),
   mockGetFileMetadataById: vi.fn(),
   mockVerifyFileAccess: vi.fn(),
   mockDownloadFile: vi.fn(),
   mockExtractEmbeddedImageIds: vi.fn(),
   mockRenderMarkdownPdf: vi.fn(),
+  mockEnforceUserRateLimit: vi.fn(),
+  mockRecordAudit: vi.fn(),
+  mockCaptureServerEvent: vi.fn(),
 }))
 
 vi.mock('@/lib/auth/hybrid', () => ({ checkSessionOrInternalAuth: mockCheckAuth }))
@@ -34,12 +40,15 @@ vi.mock('@/lib/copilot/tools/server/files/embedded-image-refs', () => ({
 vi.mock('@/app/api/files/export/[id]/markdown-pdf', () => ({
   renderMarkdownPdf: mockRenderMarkdownPdf,
 }))
+vi.mock('@/lib/core/rate-limiter/route-helpers', () => ({
+  enforceUserRateLimit: mockEnforceUserRateLimit,
+}))
 vi.mock('@sim/audit', () => ({
-  recordAudit: vi.fn(),
+  recordAudit: mockRecordAudit,
   AuditAction: { FILE_DOWNLOADED: 'file.downloaded' },
   AuditResourceType: { FILE: 'file' },
 }))
-vi.mock('@/lib/posthog/server', () => ({ captureServerEvent: vi.fn() }))
+vi.mock('@/lib/posthog/server', () => ({ captureServerEvent: mockCaptureServerEvent }))
 
 import { GET } from '@/app/api/files/export/[id]/route'
 
@@ -90,6 +99,7 @@ describe('markdown export bundling', () => {
     mockDownloadFile.mockResolvedValue(Buffer.from('# Doc\n'))
     mockExtractEmbeddedImageIds.mockReturnValue([])
     mockRenderMarkdownPdf.mockResolvedValue(Buffer.from('%PDF-generated'))
+    mockEnforceUserRateLimit.mockResolvedValue(null)
   })
 
   it('returns the stored Markdown unchanged when no format is requested', async () => {
@@ -100,6 +110,7 @@ describe('markdown export bundling', () => {
     expect(response.headers.get('Content-Disposition')).toContain('doc.md')
     expect(Buffer.from(await response.arrayBuffer()).toString()).toBe('# Doc\n')
     expect(mockRenderMarkdownPdf).not.toHaveBeenCalled()
+    expect(mockEnforceUserRateLimit).not.toHaveBeenCalled()
   })
 
   it('renders Markdown as a directly downloadable PDF', async () => {
@@ -115,6 +126,23 @@ describe('markdown export bundling', () => {
       images: expect.any(Map),
     })
     expect(mockRenderMarkdownPdf.mock.calls[0][0].images.size).toBe(0)
+    expect(mockEnforceUserRateLimit).toHaveBeenCalledWith('markdown-pdf-export', 'user-1', {
+      maxTokens: 3,
+      refillRate: 3,
+      refillIntervalMs: 60_000,
+    })
+  })
+
+  it('stops a rate-limited PDF export before reading the document', async () => {
+    mockEnforceUserRateLimit.mockResolvedValue(
+      new Response(JSON.stringify({ error: 'Rate limit exceeded' }), { status: 429 })
+    )
+
+    const response = await GET(request('pdf'), context)
+
+    expect(response.status).toBe(429)
+    expect(mockDownloadFile).not.toHaveBeenCalled()
+    expect(mockRenderMarkdownPdf).not.toHaveBeenCalled()
   })
 
   it('passes only authorized, readable embedded images to the PDF renderer', async () => {
@@ -134,6 +162,37 @@ describe('markdown export bundling', () => {
     expect(images.get('good')).toEqual(Buffer.from('png-bytes'))
   })
 
+  it('records an image-containing PDF as one downloaded file', async () => {
+    mockExtractEmbeddedImageIds.mockReturnValue(['image-1'])
+
+    await GET(request('pdf'), context)
+
+    expect(mockRecordAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({ assetCount: 1, format: 'pdf' }),
+      })
+    )
+    expect(mockCaptureServerEvent).toHaveBeenCalledWith(
+      'user-1',
+      'file_downloaded',
+      expect.objectContaining({ file_count: 1, is_bulk: false }),
+      { groups: { workspace: 'ws-1' } }
+    )
+  })
+
+  it('keeps image-containing ZIP telemetry bulk', async () => {
+    mockExtractEmbeddedImageIds.mockReturnValue(['image-1'])
+
+    await GET(request(), context)
+
+    expect(mockCaptureServerEvent).toHaveBeenCalledWith(
+      'user-1',
+      'file_downloaded',
+      expect.objectContaining({ file_count: 2, is_bulk: true }),
+      { groups: { workspace: 'ws-1' } }
+    )
+  })
+
   it('rejects PDF format for a non-Markdown file', async () => {
     mockGetFileMetadataById.mockResolvedValue({
       id: DOC_ID,
@@ -197,6 +256,25 @@ describe('markdown export bundling', () => {
     expect(bodyCall?.[0].maxBytes).toBe(250 * MB)
   })
 
+  it('uses a smaller document limit for PDF rendering', async () => {
+    await GET(request('pdf'), context)
+
+    const bodyCall = mockDownloadFile.mock.calls.find(([options]) => options.key.endsWith('doc.md'))
+    expect(bodyCall?.[0].maxBytes).toBe(256 * 1024)
+  })
+
+  it('reports an oversized PDF body with the PDF-specific limit', async () => {
+    mockDownloadFile.mockRejectedValue(
+      new PayloadSizeLimitError({ label: 'storage file download', maxBytes: 1 })
+    )
+
+    const response = await GET(request('pdf'), context)
+
+    expect(response.status).toBe(400)
+    expect((await response.json()).error).toContain('256 KB PDF export limit')
+    expect(mockRenderMarkdownPdf).not.toHaveBeenCalled()
+  })
+
   it('reports an oversized body as a size rejection, not a server error', async () => {
     mockExtractEmbeddedImageIds.mockReturnValue([])
     mockDownloadFile.mockRejectedValue(
@@ -221,6 +299,41 @@ describe('markdown export bundling', () => {
     expect(assetCall?.[0].maxBytes).toBe(25 * MB)
   })
 
+  it('uses a smaller per-asset limit for PDF rendering', async () => {
+    mockExtractEmbeddedImageIds.mockReturnValue(['a'])
+
+    await GET(request('pdf'), context)
+
+    const assetCall = mockDownloadFile.mock.calls.find(
+      ([options]) => options.key === 'workspace/ws-1/a'
+    )
+    expect(assetCall?.[0].maxBytes).toBe(10 * MB)
+  })
+
+  it('rejects PDF source material above its aggregate input limit', async () => {
+    mockExtractEmbeddedImageIds.mockReturnValue(['a', 'b'])
+    mockGetFileMetadataById.mockImplementation(async (id: string) =>
+      id === DOC_ID
+        ? {
+            id: DOC_ID,
+            key: 'workspace/ws-1/doc.md',
+            originalName: 'doc.md',
+            contentType: 'text/markdown',
+            context: 'workspace',
+            size: 1024,
+            workspaceId: 'ws-1',
+          }
+        : assetRecord(id, 30 * MB)
+    )
+
+    const response = await GET(request('pdf'), context)
+
+    expect(response.status).toBe(400)
+    expect((await response.json()).error).toContain('50 MB PDF export limit')
+    expect(mockDownloadFile).toHaveBeenCalledTimes(1)
+    expect(mockRenderMarkdownPdf).not.toHaveBeenCalled()
+  })
+
   it('drops an unreadable asset instead of failing the whole export', async () => {
     mockExtractEmbeddedImageIds.mockReturnValue(['good', 'bad'])
     mockDownloadFile.mockImplementation(async ({ key }: { key: string }) => {