fix(media): look ffprobe up on PATH before ffmpeg's sibling

The TSDoc claimed fluent-ffmpeg's order (FFPROBE_PATH, then PATH, then ffmpeg's
directory) while the code checked the sibling second, so a stray or unusable
file next to the ffmpeg binary would be cached and mask a working PATH install
for every probe. Match the documented order.

Pinned by a test in its own file: the resolved path memoizes at module scope,
so precedence is only observable in a module no other test has resolved in. It
mocks existsSync as well as execSync, without which the sibling never exists on
the test host and the two orderings are indistinguishable.

Author: waleedlatif1

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

@@ -0,0 +1,50 @@
+/**
+ * Standalone file: the resolved ffprobe path is memoized at module scope, so
+ * the first resolution in a process wins. Testing precedence therefore needs a
+ * module whose memo no other test has populated.
+ *
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+
+const { execSyncMock, execFileMock, existsSyncMock } = vi.hoisted(() => ({
+  execSyncMock: vi.fn(),
+  execFileMock: vi.fn(),
+  existsSyncMock: vi.fn(),
+}))
+
+vi.mock('node:child_process', () => ({
+  execSync: execSyncMock,
+  execFile: execFileMock,
+}))
+
+vi.mock('node:fs', () => ({
+  existsSync: existsSyncMock,
+}))
+
+import { runFfmpegOperation } from '@/lib/media/ffmpeg'
+
+describe('ffprobe lookup precedence', () => {
+  it('prefers ffprobe on PATH over a sibling of the ffmpeg binary', async () => {
+    // ffmpeg resolves into a directory whose ffprobe sibling may be stray or
+    // unusable; a real PATH entry must win. Both lookups go through execSync,
+    // so they are distinguished by the command.
+    execSyncMock.mockImplementation((cmd: string) => {
+      if (cmd.includes('ffprobe')) return '/usr/bin/ffprobe\n'
+      if (cmd.includes('ffmpeg')) return '/opt/broken/ffmpeg\n'
+      throw new Error(`unexpected command: ${cmd}`)
+    })
+    // The sibling exists on disk — without this the test cannot tell the two
+    // orderings apart, because a non-existent sibling is skipped either way.
+    existsSyncMock.mockImplementation((p: string) => p === '/opt/broken/ffprobe')
+    execFileMock.mockImplementation((_bin, _args, _opts, cb) => {
+      cb(null, JSON.stringify({ format: {}, streams: [] }), '')
+      return {}
+    })
+
+    await runFfmpegOperation('probe', [{ buffer: Buffer.from('media'), mimeType: 'video/mp4' }])
+
+    expect(execFileMock.mock.calls[0][0]).toBe('/usr/bin/ffprobe')
+    expect(execFileMock.mock.calls[0][0]).not.toBe('/opt/broken/ffprobe')
+  })
+})

apps/sim/lib/media/ffmpeg.ts

@@ -45,10 +45,20 @@ function ensureFfmpeg(): void {
   }
 }
 
+function lookupOnPath(binary: string): string | null {
+  try {
+    const cmd = process.platform === 'win32' ? `where ${binary}` : `which ${binary}`
+    return execSync(cmd, { encoding: 'utf-8' }).trim().split('\n')[0] || null
+  } catch {
+    return null
+  }
+}
+
 /**
- * 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.
+ * 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. PATH outranks the sibling deliberately:
+ * a stray or unusable file next to ffmpeg must not mask a working install.
  */
 function resolveFfprobePath(): string {
   if (ffprobePath) return ffprobePath
@@ -60,8 +70,14 @@ function resolveFfprobePath(): string {
     return ffprobePath
   }
 
+  const onPath = lookupOnPath(binary)
+  if (onPath) {
+    ffprobePath = onPath
+    return ffprobePath
+  }
+
   // Deliberately initFfmpegPath, not ensureFfmpeg: a missing ffmpeg must not
-  // stop a probe, since ffprobe may still be on PATH.
+  // stop a probe when ffprobe is installed on its own.
   initFfmpegPath()
   const sibling = ffmpegPath ? path.join(path.dirname(ffmpegPath), binary) : undefined
   ffprobePath = sibling && existsSync(sibling) ? sibling : binary