chore: import upstream snapshot with attribution

apps/sim/lib/media/falai.ts

@@ -0,0 +1,230 @@
+import { createLogger } from '@sim/logger'
+import { sleep } from '@sim/utils/helpers'
+import { isRecordLike } from '@sim/utils/object'
+import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
+import {
+  secureFetchWithPinnedIP,
+  validateUrlWithDNS,
+} from '@/lib/core/security/input-validation.server'
+import {
+  assertKnownSizeWithinLimit,
+  DEFAULT_MAX_ERROR_BODY_BYTES,
+  readResponseJsonWithLimit,
+  readResponseTextWithLimit,
+  readResponseToBufferWithLimit,
+} from '@/lib/core/utils/stream-limits'
+
+const logger = createLogger('FalMediaClient')
+
+// Generated media (esp. video) can be large.
+export const MAX_MEDIA_BYTES = 250 * 1024 * 1024
+const MAX_MEDIA_JSON_BYTES = 4 * 1024 * 1024
+const POLL_INTERVAL_MS = 3000
+
+/**
+ * Resolves a hosted Fal.ai API key from the numbered env pool
+ * (FALAI_API_KEY_COUNT + FALAI_API_KEY_1..N), round-robined by minute,
+ * mirroring getRotatingApiKey. Falls back to a single FALAI_API_KEY for dev.
+ */
+export function getFalApiKey(): string {
+  const count = Number.parseInt(process.env.FALAI_API_KEY_COUNT || '0', 10)
+  const keys: string[] = []
+  for (let i = 1; i <= count; i++) {
+    const key = process.env[`FALAI_API_KEY_${i}`]
+    if (key) keys.push(key)
+  }
+  if (keys.length === 0 && process.env.FALAI_API_KEY) {
+    keys.push(process.env.FALAI_API_KEY)
+  }
+  if (keys.length === 0) {
+    throw new Error(
+      'No hosted Fal.ai API key configured. Set FALAI_API_KEY_COUNT and FALAI_API_KEY_1..N.'
+    )
+  }
+  const index = new Date().getMinutes() % keys.length
+  return keys[index]
+}
+
+export function getStringProp(
+  record: Record<string, unknown> | undefined,
+  key: string
+): string | undefined {
+  const value = record?.[key]
+  return typeof value === 'string' ? value : undefined
+}
+
+export function getNumberProp(
+  record: Record<string, unknown> | undefined,
+  key: string
+): number | undefined {
+  const value = record?.[key]
+  return typeof value === 'number' ? value : undefined
+}
+
+function falQueueUrl(endpoint: string, requestId: string, path: 'status' | 'response'): string {
+  return `https://queue.fal.run/${endpoint}/requests/${requestId}/${path}`
+}
+
+function falErrorMessage(error: unknown): string {
+  if (typeof error === 'string') return error
+  if (isRecordLike(error)) return getStringProp(error, 'message') || JSON.stringify(error)
+  return 'Unknown Fal.ai error'
+}
+
+export interface FalQueueResult {
+  requestId: string
+  data: Record<string, unknown>
+}
+
+/**
+ * Submit input to a Fal.ai queue endpoint, poll to completion, and return the
+ * result JSON. Shared by the video and audio generators.
+ */
+export async function runFalQueue(
+  endpoint: string,
+  input: Record<string, unknown>,
+  apiKey: string
+): Promise<FalQueueResult> {
+  const createResponse = await fetch(`https://queue.fal.run/${endpoint}`, {
+    method: 'POST',
+    headers: { Authorization: `Key ${apiKey}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(input),
+  })
+  if (!createResponse.ok) {
+    const err = await readResponseTextWithLimit(createResponse, {
+      maxBytes: DEFAULT_MAX_ERROR_BODY_BYTES,
+      label: 'Fal.ai create error response',
+    }).catch(() => '')
+    throw new Error(`Fal.ai API error: ${createResponse.status} - ${err}`)
+  }
+
+  const createData = await readResponseJsonWithLimit(createResponse, {
+    maxBytes: MAX_MEDIA_JSON_BYTES,
+    label: 'Fal.ai create response',
+  })
+  if (!isRecordLike(createData)) throw new Error('Invalid Fal.ai queue response')
+
+  const requestId = getStringProp(createData, 'request_id')
+  if (!requestId) throw new Error('Fal.ai queue response missing request_id')
+
+  const statusUrl =
+    getStringProp(createData, 'status_url') || falQueueUrl(endpoint, requestId, 'status')
+  const responseUrl =
+    getStringProp(createData, 'response_url') || falQueueUrl(endpoint, requestId, 'response')
+
+  const maxAttempts = Math.ceil(getMaxExecutionTimeout() / POLL_INTERVAL_MS)
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await sleep(POLL_INTERVAL_MS)
+
+    const statusResponse = await fetch(statusUrl, { headers: { Authorization: `Key ${apiKey}` } })
+    if (!statusResponse.ok) {
+      const body = await readResponseTextWithLimit(statusResponse, {
+        maxBytes: DEFAULT_MAX_ERROR_BODY_BYTES,
+        label: 'Fal.ai status error response',
+      }).catch(() => '')
+      throw new Error(
+        `Fal.ai status check failed: ${statusResponse.status}${body ? ` - ${body}` : ''}`
+      )
+    }
+
+    const statusData = await readResponseJsonWithLimit(statusResponse, {
+      maxBytes: MAX_MEDIA_JSON_BYTES,
+      label: 'Fal.ai status response',
+    })
+    if (!isRecordLike(statusData)) throw new Error('Invalid Fal.ai status response')
+
+    const status = getStringProp(statusData, 'status')
+    if (status === 'COMPLETED') {
+      if (statusData.error) {
+        throw new Error(`Fal.ai generation failed: ${falErrorMessage(statusData.error)}`)
+      }
+      const resultResponse = await fetch(getStringProp(statusData, 'response_url') || responseUrl, {
+        headers: { Authorization: `Key ${apiKey}` },
+      })
+      if (!resultResponse.ok) {
+        const body = await readResponseTextWithLimit(resultResponse, {
+          maxBytes: DEFAULT_MAX_ERROR_BODY_BYTES,
+          label: 'Fal.ai result error response',
+        }).catch(() => '')
+        throw new Error(
+          `Failed to fetch Fal.ai result: ${resultResponse.status}${body ? ` - ${body}` : ''}`
+        )
+      }
+      const resultData = await readResponseJsonWithLimit(resultResponse, {
+        maxBytes: MAX_MEDIA_JSON_BYTES,
+        label: 'Fal.ai result response',
+      })
+      if (!isRecordLike(resultData)) throw new Error('Invalid Fal.ai result response')
+      return { requestId, data: resultData }
+    }
+
+    if (['ERROR', 'FAILED', 'CANCELLED'].includes(status || '')) {
+      throw new Error(`Fal.ai generation failed: ${falErrorMessage(statusData.error)}`)
+    }
+  }
+
+  throw new Error('Fal.ai generation timed out')
+}
+
+/**
+ * Pull the output media URL out of a Fal.ai result, tolerating the various
+ * shapes different models return (string url, { url }, nested arrays).
+ */
+export function extractFalMediaUrl(
+  data: Record<string, unknown>,
+  keys: string[]
+): string | undefined {
+  for (const key of keys) {
+    const value = data[key]
+    if (typeof value === 'string') return value
+    if (isRecordLike(value)) {
+      const url = getStringProp(value, 'url')
+      if (url) return url
+    }
+    if (Array.isArray(value)) {
+      const first = value.find(isRecordLike) as Record<string, unknown> | undefined
+      const url = getStringProp(first, 'url')
+      if (url) return url
+    }
+  }
+  return undefined
+}
+
+/** Securely download a generated media URL (or inline data URI) to a buffer. */
+export async function downloadFalMedia(
+  url: string
+): Promise<{ buffer: Buffer; contentType: string }> {
+  if (url.startsWith('data:')) {
+    const match = /^data:([^;]+);base64,(.+)$/u.exec(url)
+    if (!match) throw new Error('Invalid data URI media response')
+    const buffer = Buffer.from(match[2], 'base64')
+    assertKnownSizeWithinLimit(buffer.length, MAX_MEDIA_BYTES, 'inline media response')
+    return { contentType: match[1], buffer }
+  }
+
+  const validation = await validateUrlWithDNS(url, 'mediaUrl')
+  if (!validation.isValid || !validation.resolvedIP) {
+    throw new Error(validation.error || 'Generated media URL failed validation')
+  }
+
+  const response = await secureFetchWithPinnedIP(url, validation.resolvedIP, {
+    method: 'GET',
+    maxResponseBytes: MAX_MEDIA_BYTES,
+  })
+  if (!response.ok) {
+    await readResponseTextWithLimit(response, {
+      maxBytes: DEFAULT_MAX_ERROR_BODY_BYTES,
+      label: 'generated media error response',
+    }).catch(() => '')
+    throw new Error(`Failed to download generated media: ${response.status}`)
+  }
+
+  const contentType = response.headers.get('content-type') || 'application/octet-stream'
+  const buffer = await readResponseToBufferWithLimit(response, {
+    maxBytes: MAX_MEDIA_BYTES,
+    label: 'generated media download',
+  })
+  return { buffer, contentType }
+}
+
+export { logger as falMediaLogger }