@lightcone-ai/daemon 0.14.15 → 0.14.16

package/src/_vendor/video/recorder/index.js

@@ -0,0 +1,362 @@
+import { spawn } from 'node:child_process';
+import { mkdirSync } from 'node:fs';
+import { stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { launchChromiumMobile, openPageAndSettle } from './chromium-driver.js';
+import { defaultDisplayPool } from './display-pool.js';
+import {
+  createUnexpectedExitWatcher,
+  startFfmpegCapture,
+  stopFfmpegCapture,
+  waitForProcessExit,
+} from './ffmpeg-runner.js';
+import { executePlanPhases, normalizePlanPhases } from './plan-executor.js';
+
+const DEFAULT_VIEWPORT = Object.freeze({ width: 1080, height: 1920 });
+const DEFAULT_FPS = 30;
+
+function normalizeText(value) {
+  if (typeof value !== 'string') return '';
+  return value.trim();
+}
+
+function normalizeInteger(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+
+function normalizeViewport(viewport = {}) {
+  return {
+    width: normalizeInteger(viewport?.width, DEFAULT_VIEWPORT.width),
+    height: normalizeInteger(viewport?.height, DEFAULT_VIEWPORT.height),
+  };
+}
+
+function resolveOutputPath(rawValue) {
+  const normalized = normalizeText(rawValue);
+  if (!normalized) {
+    const error = new Error('output_path_required');
+    error.code = 'OUTPUT_PATH_REQUIRED';
+    throw error;
+  }
+  return path.resolve(normalized);
+}
+
+function resolveEventsPath(outputPath, eventsPath) {
+  const explicit = normalizeText(eventsPath);
+  if (explicit) return path.resolve(explicit);
+
+  const parsed = path.parse(outputPath);
+  return path.join(parsed.dir, `${parsed.name}.events.json`);
+}
+
+function resolveUrl({ url, plan }) {
+  const fromOptions = normalizeText(url);
+  if (fromOptions) return fromOptions;
+
+  const fromPlan = normalizeText(plan?.url ?? plan?.target_url ?? plan?.page_url);
+  if (fromPlan) return fromPlan;
+
+  const error = new Error('record_url_required');
+  error.code = 'RECORD_URL_REQUIRED';
+  throw error;
+}
+
+function estimatePlanDurationMs(plan = {}) {
+  let phases = [];
+  try {
+    phases = normalizePlanPhases(plan);
+  } catch {
+    phases = [];
+  }
+
+  return phases.reduce((total, phase) => {
+    const action = String(phase?.action ?? phase?.visual_action?.type ?? '').trim().toLowerCase();
+    const durationMs = Number(phase?.duration_ms);
+    const dwellMs = Number(phase?.dwell_ms);
+    const transitionMs = Number(phase?.transition_ms ?? phase?.visual_action?.transition_ms);
+    const effectiveHoldMs = Number.isFinite(dwellMs) && dwellMs > 0
+      ? dwellMs
+      : durationMs;
+
+    if (action === 'hold' && Number.isFinite(effectiveHoldMs) && effectiveHoldMs > 0) {
+      return total + effectiveHoldMs;
+    }
+    if (action === 'linear_scroll_during') {
+      if (Number.isFinite(effectiveHoldMs) && effectiveHoldMs > 0) return total + effectiveHoldMs;
+      return total + 1200;
+    }
+    if (action === 'scroll_to_dwell' || action === 'cursor_focus' || action === 'scroll_back') {
+      let next = total;
+      if (Number.isFinite(transitionMs) && transitionMs > 0) next += transitionMs;
+      if (Number.isFinite(effectiveHoldMs) && effectiveHoldMs > 0) next += effectiveHoldMs;
+      if (next === total) next += 1200;
+      return next;
+    }
+    if (Number.isFinite(transitionMs) && transitionMs > 0) {
+      return total + transitionMs;
+    }
+    if (Number.isFinite(durationMs) && durationMs > 0) {
+      return total + durationMs;
+    }
+    return total + 800;
+  }, 0);
+}
+
+function createXvfbExitError({ code, signal, stderr }) {
+  const error = new Error(`xvfb_exited_unexpectedly:code=${code ?? 'null'}:signal=${signal ?? 'none'}`);
+  error.code = 'XVFB_EXITED_UNEXPECTEDLY';
+  error.exitCode = code;
+  error.signal = signal;
+  error.stderr = stderr;
+  return error;
+}
+
+async function stopXvfb(runner, {
+  signal = 'SIGTERM',
+  timeoutMs = 5000,
+  killTimeoutMs = 2000,
+} = {}) {
+  const child = runner?.child;
+  if (!child || child.exitCode !== null) return child?.exitCode ?? 0;
+
+  child.kill(signal);
+  const firstExit = await waitForProcessExit(child, timeoutMs);
+  if (!firstExit.timedOut) return firstExit.code;
+
+  child.kill('SIGKILL');
+  const forceExit = await waitForProcessExit(child, killTimeoutMs);
+  return forceExit.code;
+}
+
+async function startXvfb({
+  display,
+  width,
+  height,
+  colorDepth = 24,
+  startupProbeMs = 1200,
+  xvfbBin = 'Xvfb',
+} = {}) {
+  const args = [
+    display,
+    '-screen',
+    '0',
+    `${width}x${height}x${colorDepth}`,
+    '-ac',
+    '+extension',
+    'RANDR',
+  ];
+
+  let stderr = '';
+  let spawnError = null;
+  const child = spawn(xvfbBin, args, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  child.stderr?.on('data', (chunk) => {
+    const next = `${stderr}${String(chunk)}`;
+    stderr = next.length > 8000 ? next.slice(next.length - 8000) : next;
+  });
+  child.once('error', (error) => {
+    spawnError = error;
+  });
+
+  await new Promise(resolve => setTimeout(resolve, Math.max(0, Number(startupProbeMs) || 0)));
+
+  if (spawnError) {
+    const error = new Error(`xvfb_spawn_failed:${spawnError.message}`);
+    error.code = 'XVFB_SPAWN_FAILED';
+    throw error;
+  }
+
+  if (child.exitCode !== null) {
+    throw createXvfbExitError({
+      code: child.exitCode,
+      signal: child.signalCode,
+      stderr,
+    });
+  }
+
+  const runner = {
+    child,
+    display,
+    args,
+    getStderr: () => stderr,
+    stop: (options) => stopXvfb(runner, options),
+  };
+
+  return runner;
+}
+
+async function scrollToTop(page) {
+  await page.evaluate(() => {
+    const root = document.scrollingElement || document.documentElement;
+    root.scrollTo(0, 0);
+  });
+}
+
+export async function recordUrlNarration({
+  plan,
+  output_path,
+  outputPath = output_path,
+  events_path,
+  eventsPath = events_path,
+  url,
+  viewport = DEFAULT_VIEWPORT,
+  fps = DEFAULT_FPS,
+  settle_ms = 4000,
+  displayPool = defaultDisplayPool,
+  ffmpegDurationBufferSec = 8,
+  startupProbeMs = 1200,
+  ffmpegStopTimeoutMs = 10000,
+  xvfbStopTimeoutMs = 5000,
+  postPlanTailMs = 600,
+} = {}) {
+  const phases = normalizePlanPhases(plan);
+  const executablePlan = {
+    ...(plan && typeof plan === 'object' ? plan : {}),
+    phases,
+  };
+
+  const resolvedOutputPath = resolveOutputPath(outputPath);
+  const resolvedEventsPath = resolveEventsPath(resolvedOutputPath, eventsPath);
+  const resolvedUrl = resolveUrl({ url, plan });
+  const normalizedViewport = normalizeViewport(viewport);
+  const normalizedFps = normalizeInteger(fps, DEFAULT_FPS);
+
+  mkdirSync(path.dirname(resolvedOutputPath), { recursive: true });
+  mkdirSync(path.dirname(resolvedEventsPath), { recursive: true });
+
+  let displayLease;
+  let xvfb;
+  let ffmpeg;
+  let browserSession;
+  let xvfbWatcher;
+  let ffmpegWatcher;
+  let primaryError = null;
+
+  const cleanupErrors = [];
+
+  try {
+    displayLease = await displayPool.acquireDisplay();
+    const display = displayLease.display;
+
+    xvfb = await startXvfb({
+      display,
+      width: normalizedViewport.width,
+      height: normalizedViewport.height,
+      startupProbeMs,
+    });
+    xvfbWatcher = createUnexpectedExitWatcher(xvfb.child, 'xvfb');
+
+    browserSession = await launchChromiumMobile({
+      display,
+      viewport: normalizedViewport,
+    });
+    await openPageAndSettle(browserSession.page, {
+      url: resolvedUrl,
+      settleMs: settle_ms,
+    });
+
+    const estimatedDurationMs = estimatePlanDurationMs(executablePlan);
+    const estimatedDurationSec = Math.max(
+      5,
+      Math.ceil(estimatedDurationMs / 1000) + Math.max(0, Number(ffmpegDurationBufferSec) || 0)
+    );
+
+    ffmpeg = await startFfmpegCapture({
+      display,
+      outputPath: resolvedOutputPath,
+      width: normalizedViewport.width,
+      height: normalizedViewport.height,
+      fps: normalizedFps,
+      durationSec: estimatedDurationSec,
+      startupProbeMs,
+    });
+    ffmpegWatcher = createUnexpectedExitWatcher(ffmpeg.child, 'ffmpeg');
+
+    await scrollToTop(browserSession.page);
+    await browserSession.page.waitForTimeout(350);
+
+    const eventsLog = await Promise.race([
+      executePlanPhases(browserSession.page, executablePlan),
+      xvfbWatcher.promise,
+      ffmpegWatcher.promise,
+    ]);
+
+    await browserSession.page.waitForTimeout(Math.max(0, Number(postPlanTailMs) || 0));
+
+    ffmpegWatcher.deactivate();
+    await stopFfmpegCapture(ffmpeg, {
+      timeoutMs: ffmpegStopTimeoutMs,
+    });
+
+    xvfbWatcher.deactivate();
+
+    await writeFile(resolvedEventsPath, JSON.stringify(eventsLog, null, 2), 'utf8');
+
+    const videoStat = await stat(resolvedOutputPath);
+    if (!videoStat.isFile() || videoStat.size <= 0) {
+      const error = new Error('recorded_video_empty');
+      error.code = 'RECORDED_VIDEO_EMPTY';
+      throw error;
+    }
+
+    return {
+      video_path: resolvedOutputPath,
+      events_path: resolvedEventsPath,
+      events_log: eventsLog,
+      display,
+    };
+  } catch (error) {
+    primaryError = error;
+    throw error;
+  } finally {
+    ffmpegWatcher?.deactivate();
+    xvfbWatcher?.deactivate();
+
+    if (browserSession) {
+      try {
+        await browserSession.close();
+      } catch (closeError) {
+        cleanupErrors.push(`browser_close_failed:${closeError.message}`);
+      }
+    }
+
+    if (ffmpeg) {
+      try {
+        await stopFfmpegCapture(ffmpeg, {
+          timeoutMs: ffmpegStopTimeoutMs,
+        });
+      } catch (stopError) {
+        cleanupErrors.push(`ffmpeg_stop_failed:${stopError.message}`);
+      }
+    }
+
+    if (xvfb) {
+      try {
+        await stopXvfb(xvfb, {
+          timeoutMs: xvfbStopTimeoutMs,
+        });
+      } catch (stopError) {
+        cleanupErrors.push(`xvfb_stop_failed:${stopError.message}`);
+      }
+    }
+
+    if (displayLease) {
+      displayLease.release();
+    }
+
+    if (cleanupErrors.length > 0) {
+      if (primaryError) {
+        primaryError.cleanupErrors = cleanupErrors;
+      } else {
+        const error = new Error(`record_cleanup_errors:${cleanupErrors.join('|')}`);
+        error.code = 'RECORD_CLEANUP_ERRORS';
+        throw error;
+      }
+    }
+  }
+}