fix(media): let a host with only ffprobe still probe

ensureFfmpeg() conflated 'resolve the binary' with 'require the binary', and
resolveFfprobePath called it first — so on a host with FFPROBE_PATH set but no
ffmpeg, the first probe succeeded and every later one threw, because the failed
lookup is memoized. Split the non-throwing init from the ffmpeg-required
assertion; transcoding still demands ffmpeg, probing no longer does.

Covered by a test in its own file, since the binary lookup memoizes at module
scope and a shared file would already have consumed that state.

Author: waleedlatif1

apps/sim/lib/media/ffmpeg-probe-resolution.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Standalone file: the ffmpeg module memoizes its binary lookup at module
+ * scope, so exercising the "no ffmpeg installed" branch needs a fresh module
+ * state that a shared file would already have consumed.
+ *
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { execSyncMock, execFileMock } = vi.hoisted(() => ({
+  execSyncMock: vi.fn(),
+  execFileMock: vi.fn(),
+}))
+
+vi.mock('node:child_process', () => ({
+  execSync: execSyncMock,
+  execFile: execFileMock,
+}))
+
+import { runFfmpegOperation } from '@/lib/media/ffmpeg'
+
+const PROBE_JSON = JSON.stringify({
+  format: { duration: '3', format_name: 'mov,mp4' },
+  streams: [{ codec_type: 'video', codec_name: 'h264', width: 640, height: 480 }],
+})
+
+describe('probing without a discoverable ffmpeg binary', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // No ffmpeg on this host.
+    execSyncMock.mockImplementation(() => {
+      throw new Error('which: no ffmpeg in PATH')
+    })
+    execFileMock.mockImplementation((_bin, _args, _opts, cb) => {
+      cb(null, PROBE_JSON, '')
+      return {}
+    })
+  })
+
+  it('keeps probing across repeated calls', async () => {
+    const file = { buffer: Buffer.from('media'), mimeType: 'video/mp4' }
+
+    // The second call is the regression: the binary lookup is memoized after
+    // the first, and an ffmpeg-required check here would throw from then on
+    // even though ffprobe is perfectly usable.
+    for (const _ of [1, 2, 3]) {
+      const result = await runFfmpegOperation('probe', [file])
+      expect(result.probe).toMatchObject({ hasVideo: true, width: 640, height: 480 })
+    }
+
+    expect(execFileMock).toHaveBeenCalledTimes(3)
+    expect(execFileMock.mock.calls[0][0]).toContain('ffprobe')
+  })
+
+  it('still refuses to transcode, which genuinely needs ffmpeg', async () => {
+    await expect(
+      runFfmpegOperation('convert', [{ buffer: Buffer.from('m'), mimeType: 'video/mp4' }], {
+        format: 'mp3',
+      })
+    ).rejects.toThrow('FFmpeg not found')
+  })
+})

apps/sim/lib/media/ffmpeg.ts

@@ -18,16 +18,9 @@ let ffmpegInitialized = false
 let ffmpegPath: string | null = null
 let ffprobePath: string | null = null
 
-/** Lazy system FFmpeg binary resolution, mirroring lib/audio/extractor.ts. */
-function ensureFfmpeg(): void {
-  if (ffmpegInitialized) {
-    if (!ffmpegPath) {
-      throw new Error(
-        'FFmpeg not found. Install: brew install ffmpeg (macOS) / apk add ffmpeg (Alpine) / apt-get install ffmpeg (Ubuntu)'
-      )
-    }
-    return
-  }
+/** Lazy system FFmpeg binary resolution, mirroring lib/audio/extractor.ts. Never throws. */
+function initFfmpegPath(): void {
+  if (ffmpegInitialized) return
   ffmpegInitialized = true
 
   try {
@@ -39,25 +32,39 @@ function ensureFfmpeg(): void {
   }
 }
 
+/**
+ * Transcoding requires ffmpeg itself. Probing does not — kept separate from
+ * {@link initFfmpegPath} so a host with only ffprobe can still probe.
+ */
+function ensureFfmpeg(): void {
+  initFfmpegPath()
+  if (!ffmpegPath) {
+    throw new Error(
+      'FFmpeg not found. Install: brew install ffmpeg (macOS) / apk add ffmpeg (Alpine) / apt-get install ffmpeg (Ubuntu)'
+    )
+  }
+}
+
 /**
  * Mirrors fluent-ffmpeg's resolution order (FFPROBE_PATH, then PATH, then
  * ffmpeg's own directory) so replacing its ffprobe call does not narrow where
  * the binary may live for self-hosters.
  */
 function resolveFfprobePath(): string {
-  ensureFfmpeg()
   if (ffprobePath) return ffprobePath
 
   const binary = process.platform === 'win32' ? 'ffprobe.exe' : 'ffprobe'
   const configured = process.env.FFPROBE_PATH?.trim()
-  const sibling = ffmpegPath ? path.join(path.dirname(ffmpegPath), binary) : undefined
+  if (configured && existsSync(configured)) {
+    ffprobePath = configured
+    return ffprobePath
+  }
 
-  ffprobePath =
-    configured && existsSync(configured)
-      ? configured
-      : sibling && existsSync(sibling)
-        ? sibling
-        : binary
+  // Deliberately initFfmpegPath, not ensureFfmpeg: a missing ffmpeg must not
+  // stop a probe, since ffprobe may still be on PATH.
+  initFfmpegPath()
+  const sibling = ffmpegPath ? path.join(path.dirname(ffmpegPath), binary) : undefined
+  ffprobePath = sibling && existsSync(sibling) ? sibling : binary
   return ffprobePath
 }