@olo-studio/studio-mcp 0.0.0-stage → 1.0.1

package/src/compiler.js

@@ -0,0 +1,654 @@
+/**
+ * SceneSpec v1 (`olomni.studio.scene.v1`) compiler, batch parser, and <olo-presence> embed builder.
+ * Uses Wave 1 `public/studio/engine/director.js` when available, with a deterministic offline fallback.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import vm from 'node:vm'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+
+const require = createRequire(import.meta.url)
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+export const VALID_STATES = [
+  'idle',
+  'sleeping',
+  'thinking',
+  'working',
+  'needs_approval',
+  'done',
+  'error',
+  'alert',
+  'reading',
+  'writing',
+  'searching',
+  'running',
+  'browsing',
+  'planning',
+  'delegating',
+  'tool',
+  'curious',
+  'boop',
+  'proud',
+  'yawn',
+  'look',
+]
+
+export const VALID_SCENARIOS = [
+  'studio',
+  'lofi',
+  'gamer',
+  'podcast',
+  'news',
+  'car',
+  'court',
+  'comedy',
+  'sunset',
+]
+
+export const VALID_WEARS = [
+  'none',
+  'corona',
+  'gafas_sol',
+  'auriculares',
+  'mago',
+  'laurel',
+  'boina',
+  'casco',
+  'gafas',
+  'bufanda',
+  'aureola',
+  'flor',
+  'lazo',
+]
+
+export const VALID_TINTS = [
+  'bone',
+  'mint',
+  'peach',
+  'lilac',
+  'sky',
+  'butter',
+  'rose',
+  'graphite',
+]
+
+export const VALID_FINISHES = [
+  'vinyl',
+  'chrome',
+  'frosted',
+  'gold24k',
+  'obsidian',
+  'cyberglow',
+  'uranium',
+]
+
+export const STATE_ALIASES = {
+  shocked: 'alert',
+  cringe: 'error',
+  happy: 'proud',
+  sarcastic: 'curious',
+  excited: 'proud',
+  sad: 'sleeping',
+  angry: 'error',
+  neutral: 'idle',
+  calm: 'idle',
+  think: 'thinking',
+  work: 'working',
+  read: 'reading',
+  write: 'writing',
+  search: 'searching',
+  run: 'running',
+  browse: 'browsing',
+  plan: 'planning',
+  delegate: 'delegating',
+}
+
+export const WEAR_ALIASES = {
+  gorra: 'boina',
+  cap: 'boina',
+  audifonos: 'auriculares',
+  headphones: 'auriculares',
+  lentes_pro: 'gafas',
+  glasses: 'gafas',
+  sunglasses: 'gafas_sol',
+  crown: 'corona',
+  wizard: 'mago',
+  helmet: 'casco',
+  scarf: 'bufanda',
+  halo: 'aureola',
+  flower: 'flor',
+  bow: 'lazo',
+}
+
+export const TINT_ALIASES = {
+  cobalt: 'sky',
+  jade: 'mint',
+  amber: 'butter',
+  obsidian: 'graphite',
+}
+
+export const SCENARIO_ALIASES = {
+  lofi_night: 'lofi',
+  cyber: 'gamer',
+  cyberpunk: 'gamer',
+  arcade: 'gamer',
+  neon_city: 'gamer',
+  minimal: 'studio',
+  stage: 'comedy',
+}
+
+export const FINISH_ALIASES = {
+  matte: 'vinyl',
+  glass: 'frosted',
+  gold: 'gold24k',
+  neon: 'cyberglow',
+}
+
+const PIP_MIME_TYPES = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+}
+
+/**
+ * Normalize an enum value against canonical values and legacy aliases.
+ */
+function normalizeEnumValue(raw, validList, aliasMap, fallback) {
+  if (raw === undefined || raw === null || String(raw).trim() === '') return fallback
+  const clean = String(raw).trim().toLowerCase()
+  if (validList.includes(clean)) return clean
+  if (aliasMap && aliasMap[clean] && validList.includes(aliasMap[clean])) return aliasMap[clean]
+  return fallback
+}
+
+export function normalizeState(raw, fallback = null) {
+  return normalizeEnumValue(raw, VALID_STATES, STATE_ALIASES, fallback)
+}
+
+export function normalizeWear(raw, fallback = 'gafas_sol') {
+  return normalizeEnumValue(raw, VALID_WEARS, WEAR_ALIASES, fallback)
+}
+
+export function normalizeTint(raw, fallback = 'rose') {
+  return normalizeEnumValue(raw, VALID_TINTS, TINT_ALIASES, fallback)
+}
+
+export function normalizeFinish(raw, fallback = 'vinyl') {
+  return normalizeEnumValue(raw, VALID_FINISHES, FINISH_ALIASES, fallback)
+}
+
+export function normalizeScenario(raw, fallback = 'lofi') {
+  return normalizeEnumValue(raw, VALID_SCENARIOS, SCENARIO_ALIASES, fallback)
+}
+
+let cachedDirector = null
+
+export function findPublicStudioDir(overrideDir) {
+  const candidates = [
+    overrideDir,
+    process.env.OLO_STUDIO_PUBLIC_DIR,
+    path.resolve(process.cwd(), 'public'),
+    path.resolve(__dirname, '../../../public'),
+    path.resolve(process.cwd(), 'dist'),
+    path.resolve(__dirname, '../../../dist'),
+  ].filter(Boolean)
+
+  for (const dir of candidates) {
+    if (fs.existsSync(path.join(dir, 'studio', 'studio.js'))) {
+      return dir
+    }
+  }
+  return null
+}
+
+function loadUmdModule(filePath) {
+  try {
+    const mod = require(filePath)
+    if (mod && (typeof mod.compileSceneFromScript === 'function' || typeof mod.compileScene === 'function')) {
+      return mod
+    }
+  } catch {
+    // Package "type": "module" prevents require() on .js CJS/UMD files in Node 20
+  }
+
+  // Node 22+ require(esm) returns {} for UMD scripts under "type": "module"; evaluate as CJS cleanly.
+  const code = fs.readFileSync(filePath, 'utf8')
+  const mod = { exports: {} }
+  const fn = vm.compileFunction(
+    code,
+    ['module', 'exports', 'require', '__filename', '__dirname'],
+    { filename: filePath },
+  )
+  fn(mod, mod.exports, require, filePath, path.dirname(filePath))
+  const exported = mod.exports
+  if (exported && (typeof exported.compileSceneFromScript === 'function' || typeof exported.compileScene === 'function')) {
+    return exported
+  }
+  return null
+}
+
+export function loadDirector(overridePublicDir) {
+  if (cachedDirector) return cachedDirector
+  const candidates = []
+  const publicDir = findPublicStudioDir(overridePublicDir)
+  if (publicDir) {
+    candidates.push(path.join(publicDir, 'studio', 'engine', 'director.js'))
+  }
+  // Bundled copy for external npx installs outside the repository
+  candidates.push(path.join(__dirname, 'director.js'))
+
+  for (const directorPath of candidates) {
+    if (!fs.existsSync(directorPath)) continue
+    try {
+      const loaded = loadUmdModule(directorPath)
+      if (loaded) {
+        cachedDirector = loaded
+        return cachedDirector
+      }
+    } catch {
+      // try next candidate
+    }
+  }
+  return null
+}
+
+function fnv1aHex(str) {
+  let h = 0x811c9dc5
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i)
+    h = Math.imul(h, 0x01000193)
+  }
+  return (h >>> 0).toString(16).padStart(8, '0')
+}
+
+function resolvePipMeta(opts = {}) {
+  const base = opts.pipMeta && typeof opts.pipMeta === 'object' ? { ...opts.pipMeta } : null
+  let result = base
+
+  if (opts.pipUrl && String(opts.pipUrl).trim()) {
+    result = { ...(result || {}), url: String(opts.pipUrl).trim() }
+  }
+
+  if (opts.pipPath && String(opts.pipPath).trim()) {
+    const absPath = path.resolve(String(opts.pipPath).trim())
+    if (fs.existsSync(absPath)) {
+      const ext = path.extname(absPath).toLowerCase()
+      const mimeType = PIP_MIME_TYPES[ext]
+      if (!mimeType) {
+        throw new Error(`Unsupported pipPath extension "${ext}". Supported: ${Object.keys(PIP_MIME_TYPES).join(', ')}`)
+      }
+      const buf = fs.readFileSync(absPath)
+      const dataUrl = `data:${mimeType};base64,${buf.toString('base64')}`
+      result = {
+        ...(result || {}),
+        dataUrl,
+        mimeType,
+        fileName: path.basename(absPath),
+        mediaType: mimeType.startsWith('video/') ? 'video' : 'image',
+      }
+    }
+  }
+
+  return result
+}
+
+function normalizeCompileOpts(input = {}) {
+  const opts = input && typeof input === 'object' ? { ...input } : { script: String(input || '') }
+
+  if (!opts.script && !opts.scriptText && Array.isArray(opts.beats)) {
+    opts.script = opts.beats.map((b) => `${b.speaker || 'Olo'}: ${b.text || b.line || ''}`).join('\n')
+  }
+
+  if (opts.wear !== undefined) opts.wear = normalizeWear(opts.wear)
+  if (opts.tint !== undefined) opts.tint = normalizeTint(opts.tint)
+  if (opts.finish !== undefined || opts.collectorFinish !== undefined) {
+    opts.finish = normalizeFinish(opts.finish ?? opts.collectorFinish)
+  }
+  if (opts.scenario !== undefined) opts.scenario = normalizeScenario(opts.scenario)
+
+  const rawState = opts.stateOverride ?? opts.state ?? opts.emotion
+  if (rawState !== undefined && rawState !== null) {
+    opts.stateOverride = normalizeState(rawState, null)
+  }
+
+  opts.pipMeta = resolvePipMeta(opts)
+  return opts
+}
+
+function fallbackCompileScene(opts = {}) {
+  const rawScript = String(
+    opts.script ||
+      opts.scriptText ||
+      (Array.isArray(opts.beats)
+        ? opts.beats.map((b) => `${b.speaker || 'Olo'}: ${b.text || b.line || ''}`).join('\n')
+        : 'Olo: Hola mundo desde Olomni Studio.'),
+  ).trim()
+
+  const maxLines = Math.max(1, Math.min(30, Number(opts.maxLines) || 12))
+  const lines = rawScript.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(0, maxLines)
+
+  const title = String(opts.title || 'Olo Studio Show').slice(0, 60)
+  const category = String(opts.category || 'Show 9:16').slice(0, 32)
+  const wear = normalizeWear(opts.wear, 'gafas_sol')
+  const tint = normalizeTint(opts.tint, 'rose')
+  const finish = normalizeFinish(opts.finish || opts.collectorFinish, 'vinyl')
+  const vibe = opts.vibe || 'drama'
+  const scenario = normalizeScenario(opts.scenario, 'lofi')
+  const cameraOverride = opts.cameraOverride || 'auto'
+  const stateOverride = normalizeState(opts.stateOverride ?? opts.state ?? opts.emotion, null)
+
+  let tCursor = 0.45
+  const beats = lines.map((raw, idx) => {
+    let speaker = 'Olo'
+    let text = raw
+    const colonIdx = raw.indexOf(':')
+    if (colonIdx > 0 && colonIdx < 18) {
+      speaker = raw.slice(0, colonIdx).trim()
+      text = raw.slice(colonIdx + 1).trim()
+    }
+    const wordCount = text.split(/\s+/).filter(Boolean).length
+    const duration = Number(Math.max(2.1, Math.min(4.4, 0.75 + wordCount * 0.27)).toFixed(3))
+    const t0 = Number(tCursor.toFixed(3))
+    const t1 = Number((tCursor + duration).toFixed(3))
+    tCursor = t1 + 0.12
+
+    const overrideBeat = Array.isArray(opts.beats) ? opts.beats[idx] : null
+    const beatState = overrideBeat
+      ? normalizeState(overrideBeat.state ?? overrideBeat.emotion, null)
+      : null
+    return {
+      index: idx,
+      speaker,
+      isOlo: speaker.toLowerCase().includes('olo'),
+      text,
+      t0,
+      t1,
+      duration,
+      state: beatState || stateOverride || (idx === 0 ? 'alert' : idx === lines.length - 1 ? 'done' : 'working'),
+      cam: (overrideBeat && overrideBeat.cam) || (cameraOverride !== 'auto' ? cameraOverride : 'hero'),
+      sfx: (overrideBeat && overrideBeat.sfx) || 'pop',
+      words: [],
+    }
+  })
+
+  const outroStart = Number(tCursor.toFixed(3))
+  const totalDuration = Number((tCursor + 1.35).toFixed(3))
+  const sceneHash = fnv1aHex(JSON.stringify({ title, wear, tint, finish, scenario, beats: beats.map((b) => [b.speaker, b.text]) }))
+
+  const spec = {
+    schema: 'olomni.studio.scene.v1',
+    sceneHash,
+    title,
+    category,
+    wear: wear === 'none' ? null : wear,
+    tint,
+    finish,
+    vibe,
+    scenario,
+    cameraOverride,
+    stateOverride,
+    duelConfig: opts.duelConfig && typeof opts.duelConfig === 'object' ? { ...opts.duelConfig } : null,
+    voice: opts.voice ? String(opts.voice).trim() : null,
+    voiceId: opts.voiceId ? String(opts.voiceId).trim() : null,
+    captions: opts.captions !== false,
+    voiceFx: opts.voiceFx || 'none',
+    drillBeat: opts.drillBeat || null,
+    customOutro: opts.customOutro || null,
+    pipMeta: opts.pipMeta || null,
+    duration: totalDuration,
+    outroStart,
+    beats,
+  }
+  if (typeof opts.watermark === 'boolean') spec.watermark = opts.watermark
+  return spec
+}
+
+export function compileSceneSpec(input = {}) {
+  const opts = normalizeCompileOpts(input)
+
+  const director = loadDirector(opts.publicDir)
+  let scene
+  if (director && typeof director.compileSceneFromScript === 'function') {
+    scene = director.compileSceneFromScript(opts)
+  } else if (director && typeof director.compileScene === 'function') {
+    scene = director.compileScene(opts)
+  } else {
+    scene = fallbackCompileScene(opts)
+  }
+
+  // Preserve explicit per-beat overrides (state / emotion, cam, sfx) if caller supplied beats[]
+  if (Array.isArray(opts.beats) && Array.isArray(scene.beats)) {
+    scene.beats.forEach((b, idx) => {
+      const src = opts.beats[idx]
+      if (!src || typeof src !== 'object') return
+      const normalizedBeatState = normalizeState(src.state ?? src.emotion, null)
+      if (normalizedBeatState) b.state = normalizedBeatState
+      if (src.cam) b.cam = src.cam
+      if (src.sfx) b.sfx = src.sfx
+    })
+  }
+
+  scene.duelConfig = opts.duelConfig && typeof opts.duelConfig === 'object'
+    ? { ...opts.duelConfig }
+    : (scene.duelConfig || null)
+  scene.voice = opts.voice ? String(opts.voice).trim() : (scene.voice || null)
+  scene.voiceId = opts.voiceId ? String(opts.voiceId).trim() : (scene.voiceId || null)
+  scene.captions = opts.captions !== false
+  if (opts.pipMeta) scene.pipMeta = opts.pipMeta
+
+  if (typeof opts.watermark === 'boolean') {
+    scene.watermark = opts.watermark
+  }
+
+  return scene
+}
+
+function parseCsvLine(line) {
+  const cells = []
+  let current = ''
+  let inQuotes = false
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i]
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"'
+        i++
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (ch === ',' && !inQuotes) {
+      cells.push(current.trim())
+      current = ''
+    } else {
+      current += ch
+    }
+  }
+  cells.push(current.trim())
+  return cells
+}
+
+export function parseBatchInput({ specs, csv, defaults = {} }) {
+  const cleanDefaults = Object.fromEntries(
+    Object.entries(defaults || {}).filter(([, v]) => v !== undefined),
+  )
+
+  if (Array.isArray(specs) && specs.length > 0) {
+    return specs.map((item, idx) => {
+      const compiled = compileSceneSpec({ ...cleanDefaults, ...item })
+      return {
+        index: idx,
+        outputName: item.outputName || item.fileName || `variant-${idx + 1}-${compiled.sceneHash}`,
+        sceneSpec: compiled,
+      }
+    })
+  }
+
+  if (typeof csv === 'string' && csv.trim()) {
+    const rows = csv.split(/\r?\n/).map((r) => r.trim()).filter(Boolean)
+    if (rows.length < 2) {
+      throw new Error('CSV must include a header row and at least one data row.')
+    }
+    const headers = parseCsvLine(rows[0]).map((h) => h.toLowerCase())
+    return rows.slice(1).map((row, idx) => {
+      const values = parseCsvLine(row)
+      const record = {}
+      headers.forEach((h, colIdx) => {
+        if (values[colIdx] !== undefined && values[colIdx] !== '') {
+          record[h] = values[colIdx]
+        }
+      })
+      const compiled = compileSceneSpec({
+        ...cleanDefaults,
+        title: record.title || `Variant ${idx + 1}`,
+        script: record.script || record.hook || record.text || '',
+        wear: record.wear,
+        tint: record.tint,
+        finish: record.finish,
+        scenario: record.scenario,
+        vibe: record.vibe,
+        voice: record.voice ?? cleanDefaults.voice,
+        voiceId: record.voiceid || record.voice_id || cleanDefaults.voiceId,
+        emotion: record.emotion,
+        stateOverride: record.state || record.stateoverride,
+        captions: record.captions !== undefined
+          ? record.captions !== 'false' && record.captions !== '0'
+          : (cleanDefaults.captions !== undefined ? cleanDefaults.captions : true),
+        pipPath: record.pippath || record.pip_path || cleanDefaults.pipPath,
+        pipUrl: record.pipurl || record.pip_url || cleanDefaults.pipUrl,
+        category: record.category || record.language || 'Show 9:16',
+      })
+      const safeName = (record.outputname || record.output_name || record.id || `variant-${idx + 1}-${compiled.sceneHash}`)
+        .replace(/[^a-zA-Z0-9_-]/g, '_')
+      return {
+        index: idx,
+        outputName: safeName,
+        sceneSpec: compiled,
+      }
+    })
+  }
+
+  throw new Error('Provide either a non-empty `specs` array or a `csv` string.')
+}
+
+function formatSrtTimestamp(seconds) {
+  const safeSec = Math.max(0, Number(seconds) || 0)
+  const totalMs = Math.round(safeSec * 1000)
+  const ms = totalMs % 1000
+  const totalS = Math.floor(totalMs / 1000)
+  const s = totalS % 60
+  const totalM = Math.floor(totalS / 60)
+  const m = totalM % 60
+  const h = Math.floor(totalM / 60)
+  const pad2 = (n) => String(n).padStart(2, '0')
+  const pad3 = (n) => String(n).padStart(3, '0')
+  return `${pad2(h)}:${pad2(m)}:${pad2(s)},${pad3(ms)}`
+}
+
+/**
+ * Build valid .srt timed captions from scene.timeline, scene.beats, or scene.script.
+ */
+export function generateSrt(scene) {
+  if (!scene) return ''
+
+  let cues = []
+  if (typeof scene === 'string') {
+    cues = compileSceneSpec({ script: scene }).beats || []
+  } else if (Array.isArray(scene.timeline) && scene.timeline.length > 0) {
+    cues = scene.timeline
+  } else if (Array.isArray(scene.beats) && scene.beats.length > 0) {
+    cues = scene.beats
+  } else if (typeof scene.script === 'string' && scene.script.trim()) {
+    cues = compileSceneSpec({ script: scene.script }).beats || []
+  } else if (typeof scene.scriptText === 'string' && scene.scriptText.trim()) {
+    cues = compileSceneSpec({ script: scene.scriptText }).beats || []
+  }
+
+  let cursor = 0
+  const blocks = []
+  for (const item of cues) {
+    if (!item || typeof item !== 'object') continue
+    const rawText = String(item.text || item.line || item.caption || '').trim()
+    if (!rawText) continue
+    const speaker = item.speaker ? String(item.speaker).trim() : ''
+    const lineText = speaker && !rawText.startsWith(`${speaker}:`) ? `${speaker}: ${rawText}` : rawText
+
+    const t0 = Number.isFinite(Number(item.t0 ?? item.start ?? item.startSec))
+      ? Number(item.t0 ?? item.start ?? item.startSec)
+      : cursor
+    const rawT1 = item.t1 ?? item.end ?? item.endSec
+    const t1 = Number.isFinite(Number(rawT1))
+      ? Math.max(t0 + 0.1, Number(rawT1))
+      : t0 + Math.max(0.5, Number(item.duration) || 2.5)
+    cursor = t1 + 0.12
+
+    blocks.push(
+      `${blocks.length + 1}\n${formatSrtTimestamp(t0)} --> ${formatSrtTimestamp(t1)}\n${lineText}`,
+    )
+  }
+
+  return blocks.length > 0 ? `${blocks.join('\n\n')}\n` : ''
+}
+
+function escapeHtmlAttr(val) {
+  return String(val)
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}
+
+const EMBED_ATTR_MAP = {
+  mascotId: 'mascot-id',
+  brand: 'brand',
+  glbUrl: 'glb-url',
+  skin: 'skin',
+  wear: 'wear',
+  tint: 'tint',
+  themeColor: 'theme-color',
+  greeting: 'greeting',
+  ctaLabel: 'cta-label',
+  ctaUrl: 'cta-url',
+  voice: 'voice',
+  voiceId: 'voice-id',
+  position: 'position',
+  apiBase: 'api-base',
+  apiEndpoint: 'api-endpoint',
+  ttsEndpoint: 'tts-endpoint',
+  systemPrompt: 'system-prompt',
+  knowledge: 'knowledge',
+}
+
+export function buildPublishEmbed(opts = {}) {
+  const scriptSrc = opts.scriptSrc || 'https://www.olomni.com/studio/embed/olo-presence.js'
+  const attrs = []
+
+  for (const [key, attrName] of Object.entries(EMBED_ATTR_MAP)) {
+    const raw = opts[key] ?? opts[attrName]
+    if (raw === undefined || raw === null) continue
+    const val = typeof raw === 'object' ? JSON.stringify(raw) : String(raw)
+    if (val.trim() !== '') {
+      attrs.push(`  ${attrName}="${escapeHtmlAttr(val)}"`)
+    }
+  }
+  if (opts.open === true) {
+    attrs.push('  open')
+  }
+
+  const attrBlock = attrs.length > 0 ? `\n${attrs.join('\n')}\n` : ''
+  const html = [
+    `<script src="${escapeHtmlAttr(scriptSrc)}" defer></script>`,
+    `<olo-presence${attrBlock}></olo-presence>`,
+  ].join('\n')
+
+  return {
+    ok: true,
+    scriptSrc,
+    tagName: 'olo-presence',
+    html,
+  }
+}