Sandbox exports decode by the path rule the reader used: a .jpg declared without a format is written as image/jpeg bytes, not as its base64 text under the json format (thumbnails opened as raw text)

Author: Sg312

apps/sim/lib/execution/remote-sandbox/index.ts

@@ -38,6 +38,7 @@ import {
   repairMissingSandboxImage,
   resolveWorkspaceSandbox,
 } from '@/lib/execution/remote-sandbox/resolve'
+import { isBinarySandboxPath } from '@/lib/execution/remote-sandbox/sandbox-encoding'
 import {
   SANDBOX_OUTPUT_DIR_MAX_DEPTH,
   SANDBOX_OUTPUT_DIR_SENTINEL,
@@ -593,25 +594,6 @@ const SIM_RESULT_CORRUPTED_ERROR =
   "Do not trust or persist this call's output. For large results, write the content to a " +
   'file inside the sandbox and export it via outputs.files[].sandboxPath instead of returning it.'
 
-function shouldReadSandboxPathAsBase64(outputSandboxPath: string): boolean {
-  const ext = outputSandboxPath.slice(outputSandboxPath.lastIndexOf('.')).toLowerCase()
-  const binaryExts = new Set([
-    '.png',
-    '.jpg',
-    '.jpeg',
-    '.gif',
-    '.webp',
-    '.pdf',
-    '.zip',
-    '.mp3',
-    '.mp4',
-    '.docx',
-    '.pptx',
-    '.xlsx',
-  ])
-  return binaryExts.has(ext)
-}
-
 async function readSandboxOutputFile(
   sandbox: SandboxHandle,
   outputSandboxPath: string,
@@ -621,7 +603,7 @@ async function readSandboxOutputFile(
   try {
     return await sandbox.readFileWithLimit(outputSandboxPath, {
       maxBytes,
-      encoding: shouldReadSandboxPathAsBase64(outputSandboxPath) ? 'base64' : 'utf8',
+      encoding: isBinarySandboxPath(outputSandboxPath) ? 'base64' : 'utf8',
       signal: options?.signal,
     })
   } catch (error) {

apps/sim/lib/execution/remote-sandbox/sandbox-encoding.test.ts

@@ -0,0 +1,33 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { isBinarySandboxPath } from '@/lib/execution/remote-sandbox/sandbox-encoding'
+
+describe('isBinarySandboxPath', () => {
+  it('treats image, document, and archive extensions as binary regardless of case', () => {
+    for (const path of [
+      '/home/user/a.jpg',
+      '/tmp/B.PNG',
+      '/x/report.pdf',
+      '/x/deck.pptx',
+      '/x/data.xlsx',
+      '/x/a.zip',
+    ]) {
+      expect(isBinarySandboxPath(path)).toBe(true)
+    }
+  })
+
+  it('treats text formats and unknown extensions as text', () => {
+    for (const path of [
+      '/home/user/a.json',
+      '/tmp/rows.csv',
+      '/x/notes.md',
+      '/x/script.py',
+      '/x/noext',
+      '/x/data.parquet',
+    ]) {
+      expect(isBinarySandboxPath(path)).toBe(false)
+    }
+  })
+})

apps/sim/lib/execution/remote-sandbox/sandbox-encoding.ts

@@ -0,0 +1,29 @@
+/**
+ * How a declared sandbox output path is read back and, therefore, how its content must be
+ * decoded. The reader (remote-sandbox) and the exporter (function-execution) must agree
+ * on this per path: a `.jpg` read as base64 and then classified as text by its (unknown)
+ * output format was stored verbatim as base64 text under an `image/jpeg`-less name.
+ */
+const BINARY_EXTENSIONS: ReadonlySet<string> = new Set([
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.webp',
+  '.pdf',
+  '.zip',
+  '.mp3',
+  '.mp4',
+  '.docx',
+  '.pptx',
+  '.xlsx',
+])
+
+/**
+ * True when a declared output path is read from the sandbox as base64 bytes rather than
+ * UTF-8 text.
+ */
+export function isBinarySandboxPath(sandboxPath: string): boolean {
+  const ext = sandboxPath.slice(sandboxPath.lastIndexOf('.')).toLowerCase()
+  return BINARY_EXTENSIONS.has(ext)
+}

apps/sim/lib/function-execution/execute-request.test.ts

@@ -932,6 +932,89 @@ describe('Function execution request', () => {
       ])
     })
 
+    it('exports a .jpg declared without a format as image/jpeg bytes, never as base64 text', async () => {
+      // The sandbox reads a .jpg back as base64; the exporter used to classify it by its
+      // (unknown) output format, default to json, and store the base64 string verbatim.
+      envFlagsMock.isRemoteSandboxEnabled = true
+      const jpegBase64 = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10]).toString('base64')
+      mockExecuteInSandbox.mockResolvedValueOnce({
+        result: 'done',
+        stdout: 'ok',
+        sandboxId: 'sandbox-123',
+        cost: { input: 0, output: 0, total: 0.0001 },
+        exportedFiles: {
+          '/home/user/thumbs/01.jpg': jpegBase64,
+          '/home/user/summary.json': '{"ok":true}',
+        },
+      })
+
+      const req = createMockRequest('POST', {
+        code: 'print("done")',
+        language: 'python',
+        workspaceId: 'workspace-1',
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+        outputs: {
+          files: [
+            {
+              path: 'files/thumbs/01.jpg',
+              mode: 'create',
+              sandboxPath: '/home/user/thumbs/01.jpg',
+            },
+            { path: 'files/summary.json', mode: 'create', sandboxPath: '/home/user/summary.json' },
+          ],
+        },
+      })
+
+      const response = await POST(req)
+      expect(response.status).toBe(200)
+      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledTimes(2)
+      const [jpgCall, jsonCall] = mockWriteWorkspaceFileByPath.mock.calls.map((call) => call[0])
+      expect(jpgCall.target).toEqual(expect.objectContaining({ path: 'files/thumbs/01.jpg' }))
+      expect(jpgCall.inferredMimeType).toBe('image/jpeg')
+      expect(Buffer.from(jpgCall.buffer).equals(Buffer.from(jpegBase64, 'base64'))).toBe(true)
+      expect(jsonCall.target).toEqual(expect.objectContaining({ path: 'files/summary.json' }))
+      expect(jsonCall.inferredMimeType).toBe('application/json')
+      expect(Buffer.from(jsonCall.buffer).toString('utf-8')).toBe('{"ok":true}')
+    })
+
+    it('exports a single .jpg declared without a format as image/jpeg bytes (single-file path)', async () => {
+      envFlagsMock.isRemoteSandboxEnabled = true
+      const jpegBase64 = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10]).toString('base64')
+      mockExecuteInSandbox.mockResolvedValueOnce({
+        result: 'done',
+        stdout: 'ok',
+        sandboxId: 'sandbox-123',
+        cost: { input: 0, output: 0, total: 0.0001 },
+        exportedFiles: { '/home/user/thumbs/02.jpg': jpegBase64 },
+      })
+
+      const req = createMockRequest('POST', {
+        code: 'print("done")',
+        language: 'python',
+        workspaceId: 'workspace-1',
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+        outputs: {
+          files: [
+            {
+              path: 'files/thumbs/02.jpg',
+              mode: 'create',
+              sandboxPath: '/home/user/thumbs/02.jpg',
+            },
+          ],
+        },
+      })
+
+      const response = await POST(req)
+      expect(response.status).toBe(200)
+      expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledTimes(1)
+      const call = mockWriteWorkspaceFileByPath.mock.calls[0]?.[0]
+      expect(call.target).toEqual(expect.objectContaining({ path: 'files/thumbs/02.jpg' }))
+      expect(call.inferredMimeType).toBe('image/jpeg')
+      expect(Buffer.from(call.buffer).equals(Buffer.from(jpegBase64, 'base64'))).toBe(true)
+    })
+
     it("keeps the code's returned rows beside the sandbox export receipt", async () => {
       envFlagsMock.isRemoteSandboxEnabled = true
       const rows = [{ name: 'Ada' }, { name: 'Grace' }]

apps/sim/lib/function-execution/execute-request.ts

@@ -73,6 +73,7 @@ import {
   MAX_SANDBOX_OUTPUT_BYTES,
   readTrustedSandboxOutputCost,
 } from '@/lib/execution/remote-sandbox/output-limits'
+import { isBinarySandboxPath } from '@/lib/execution/remote-sandbox/sandbox-encoding'
 import {
   MAX_BLOCK_MOUNTED_FILES,
   SANDBOX_OUTPUT_DIR,
@@ -1588,12 +1589,16 @@ async function maybeExportSandboxFileToWorkspace(args: {
 
   const fileName = normalizeOutputWorkspaceFileName(outputPath)
 
-  const TEXT_MIMES = new Set(Object.values(FORMAT_TO_CONTENT_TYPE))
+  // Decode the way the sandbox read it (by path), never by guessing from the mime: a
+  // `.jpg` with no declared format resolved to the json text format and was stored as
+  // its base64 text (dev, 2026-09-03: thumbnails that opened as "raw text").
+  const isBinary = isBinarySandboxPath(outputSandboxPath)
   const resolvedMimeType =
     outputMimeType ||
-    FORMAT_TO_CONTENT_TYPE[resolveOutputFormat(fileName, outputFormat)] ||
+    (isBinary
+      ? getMimeTypeFromExtension(getFileExtension(fileName))
+      : FORMAT_TO_CONTENT_TYPE[resolveOutputFormat(fileName, outputFormat)]) ||
     'application/octet-stream'
-  const isBinary = !TEXT_MIMES.has(resolvedMimeType)
   const outputBytes = Buffer.byteLength(exportedFileContent, isBinary ? 'base64' : 'utf-8')
   if (outputBytes > MAX_SANDBOX_OUTPUT_BYTES) {
     return exportFailure(
@@ -1766,11 +1771,14 @@ async function maybeExportSandboxFilesToWorkspace(args: {
     }
     const outputPath = file.formatPath ?? file.path
     const fileName = normalizeOutputWorkspaceFileName(outputPath)
+    // Same rule as the single-file export: the sandbox path decides the encoding.
+    const isBinary = isBinarySandboxPath(sandboxPath)
     const resolvedMimeType =
       file.mimeType ||
-      FORMAT_TO_CONTENT_TYPE[resolveOutputFormat(fileName, file.format)] ||
+      (isBinary
+        ? getMimeTypeFromExtension(getFileExtension(fileName))
+        : FORMAT_TO_CONTENT_TYPE[resolveOutputFormat(fileName, file.format)]) ||
       'application/octet-stream'
-    const isBinary = !new Set(Object.values(FORMAT_TO_CONTENT_TYPE)).has(resolvedMimeType)
     const size = Buffer.byteLength(content, isBinary ? 'base64' : 'utf-8')
     totalOutputBytes += size
     if (totalOutputBytes > MAX_SANDBOX_OUTPUT_BYTES) {