@lightcone-ai/daemon 0.23.6 → 0.23.8

package/src/tools/record-url-narration.js

@@ -1,6 +1,6 @@
 // V6 record_url_narration daemon tool wrapper.
 //
-// Drives Chromium on Xvfb + Playwright recordVideo to capture a silent mp4
+// Drives headless Chromium + Playwright recordVideo to capture a silent mp4
 // per section, then ffmpeg-transcodes + slices. The resulting silent mp4s
 // feed compose_video_v2 as video-kind segments alongside narration audio.
 //

package/src/_vendor/video/recorder/display-pool.js

@@ -1,126 +0,0 @@
-const DEFAULT_BASE_DISPLAY = 99;
-const DEFAULT_POOL_SIZE = 3;
-
-function normalizePositiveInteger(value, fallback) {
-  const parsed = Number.parseInt(String(value ?? ''), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-  return parsed;
-}
-
-function createAcquireTimeoutError(timeoutMs) {
-  const error = new Error(`display_pool_acquire_timeout:${timeoutMs}ms`);
-  error.code = 'DISPLAY_POOL_ACQUIRE_TIMEOUT';
-  return error;
-}
-
-function createInvalidPoolError() {
-  const error = new Error('display_pool_invalid_configuration');
-  error.code = 'DISPLAY_POOL_INVALID_CONFIGURATION';
-  return error;
-}
-
-function createSlots({ baseDisplay, poolSize }) {
-  return Array.from({ length: poolSize }, (_unused, index) => {
-    const displayNumber = baseDisplay + index;
-    return {
-      displayNumber,
-      display: `:${displayNumber}`,
-      inUse: false,
-    };
-  });
-}
-
-function createLease(slot, releaseSlot) {
-  let released = false;
-  return Object.freeze({
-    display: slot.display,
-    displayNumber: slot.displayNumber,
-    release() {
-      if (released) return false;
-      released = true;
-      releaseSlot(slot);
-      return true;
-    },
-  });
-}
-
-export function createDisplayPool({
-  baseDisplay = DEFAULT_BASE_DISPLAY,
-  maxConcurrent = DEFAULT_POOL_SIZE,
-} = {}) {
-  const normalizedBaseDisplay = normalizePositiveInteger(baseDisplay, DEFAULT_BASE_DISPLAY);
-  const normalizedPoolSize = normalizePositiveInteger(maxConcurrent, DEFAULT_POOL_SIZE);
-  if (!Number.isFinite(normalizedBaseDisplay) || !Number.isFinite(normalizedPoolSize)) {
-    throw createInvalidPoolError();
-  }
-
-  const slots = createSlots({
-    baseDisplay: normalizedBaseDisplay,
-    poolSize: normalizedPoolSize,
-  });
-  const waiters = [];
-
-  function reserveAvailableSlot() {
-    const slot = slots.find((candidate) => !candidate.inUse);
-    if (!slot) return null;
-    slot.inUse = true;
-    return slot;
-  }
-
-  function dispatchWaiters() {
-    while (waiters.length > 0) {
-      const slot = reserveAvailableSlot();
-      if (!slot) return;
-      const waiter = waiters.shift();
-      if (!waiter) return;
-      if (waiter.timer) clearTimeout(waiter.timer);
-      waiter.resolve(createLease(slot, releaseSlot));
-    }
-  }
-
-  function releaseSlot(slot) {
-    slot.inUse = false;
-    dispatchWaiters();
-  }
-
-  async function acquireDisplay({ timeoutMs = null } = {}) {
-    const slot = reserveAvailableSlot();
-    if (slot) return createLease(slot, releaseSlot);
-
-    return await new Promise((resolve, reject) => {
-      const waiter = {
-        resolve,
-        reject,
-        timer: null,
-      };
-      if (Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0) {
-        const normalizedTimeoutMs = Math.floor(Number(timeoutMs));
-        waiter.timer = setTimeout(() => {
-          const waiterIndex = waiters.indexOf(waiter);
-          if (waiterIndex >= 0) waiters.splice(waiterIndex, 1);
-          reject(createAcquireTimeoutError(normalizedTimeoutMs));
-        }, normalizedTimeoutMs);
-      }
-      waiters.push(waiter);
-    });
-  }
-
-  function snapshot() {
-    return {
-      baseDisplay: normalizedBaseDisplay,
-      maxConcurrent: normalizedPoolSize,
-      waiting: waiters.length,
-      inUse: slots.filter(slot => slot.inUse).map(slot => slot.display),
-      available: slots.filter(slot => !slot.inUse).map(slot => slot.display),
-    };
-  }
-
-  return Object.freeze({
-    baseDisplay: normalizedBaseDisplay,
-    maxConcurrent: normalizedPoolSize,
-    acquireDisplay,
-    snapshot,
-  });
-}
-
-export const defaultDisplayPool = createDisplayPool();

package/src/_vendor/video/recorder/ffmpeg-runner.js

@@ -1,291 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
-
-const DEFAULT_FPS = 30;
-const DEFAULT_WIDTH = 1080;
-const DEFAULT_HEIGHT = 1920;
-const DEFAULT_PRESET = 'veryfast';
-const DEFAULT_VIDEO_BITRATE = '4500k';
-const DEFAULT_VIDEO_MAX_RATE = '5500k';
-const DEFAULT_VIDEO_BUFFER_SIZE = '9000k';
-
-function normalizeInteger(value, fallback) {
-  const parsed = Number.parseInt(String(value ?? ''), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-  return parsed;
-}
-
-function normalizeText(value) {
-  if (typeof value !== 'string') return '';
-  return value.trim();
-}
-
-function normalizeOutputPath(outputPath) {
-  const normalized = normalizeText(outputPath);
-  if (!normalized) {
-    const error = new Error('ffmpeg_output_path_required');
-    error.code = 'FFMPEG_OUTPUT_PATH_REQUIRED';
-    throw error;
-  }
-  return path.resolve(normalized);
-}
-
-function normalizeDisplay(display) {
-  const normalized = normalizeText(display);
-  if (!/^:\d+$/.test(normalized)) {
-    const error = new Error(`ffmpeg_display_invalid:${normalized || 'empty'}`);
-    error.code = 'FFMPEG_DISPLAY_INVALID';
-    throw error;
-  }
-  return normalized;
-}
-
-function appendLogChunk(current, chunk, maxLength = 8000) {
-  const merged = `${current}${chunk}`;
-  if (merged.length <= maxLength) return merged;
-  return merged.slice(merged.length - maxLength);
-}
-
-function buildExitError({ name, code, signal, stderr = '', stdout = '' }) {
-  const descriptor = `${name}_exited_unexpectedly:code=${code ?? 'null'}:signal=${signal ?? 'none'}`;
-  const error = new Error(descriptor);
-  error.code = `${String(name).toUpperCase()}_EXITED_UNEXPECTEDLY`;
-  error.exitCode = code;
-  error.signal = signal;
-  error.stderr = stderr;
-  error.stdout = stdout;
-  return error;
-}
-
-export function buildFfmpegX11grabArgs({
-  display,
-  outputPath,
-  width = DEFAULT_WIDTH,
-  height = DEFAULT_HEIGHT,
-  fps = DEFAULT_FPS,
-  durationSec = null,
-  preset = DEFAULT_PRESET,
-  videoBitrate = DEFAULT_VIDEO_BITRATE,
-  maxRate = DEFAULT_VIDEO_MAX_RATE,
-  bufferSize = DEFAULT_VIDEO_BUFFER_SIZE,
-  logLevel = 'warning',
-  extraArgs = [],
-} = {}) {
-  const normalizedDisplay = normalizeDisplay(display);
-  const normalizedOutputPath = normalizeOutputPath(outputPath);
-  const normalizedWidth = normalizeInteger(width, DEFAULT_WIDTH);
-  const normalizedHeight = normalizeInteger(height, DEFAULT_HEIGHT);
-  const normalizedFps = normalizeInteger(fps, DEFAULT_FPS);
-
-  const args = [
-    '-y',
-    '-hide_banner',
-    '-loglevel', normalizeText(logLevel) || 'warning',
-    '-f', 'x11grab',
-    '-draw_mouse', '1',
-    '-framerate', String(normalizedFps),
-    '-video_size', `${normalizedWidth}x${normalizedHeight}`,
-    '-i', normalizedDisplay,
-  ];
-
-  const normalizedDurationSec = Number(durationSec);
-  if (Number.isFinite(normalizedDurationSec) && normalizedDurationSec > 0) {
-    args.push('-t', String(Math.ceil(normalizedDurationSec)));
-  }
-
-  args.push(
-    '-c:v', 'libx264',
-    '-preset', normalizeText(preset) || DEFAULT_PRESET,
-    '-pix_fmt', 'yuv420p',
-    '-b:v', normalizeText(videoBitrate) || DEFAULT_VIDEO_BITRATE,
-    '-maxrate', normalizeText(maxRate) || DEFAULT_VIDEO_MAX_RATE,
-    '-bufsize', normalizeText(bufferSize) || DEFAULT_VIDEO_BUFFER_SIZE,
-    '-r', String(normalizedFps),
-    '-movflags', '+faststart',
-  );
-
-  if (Array.isArray(extraArgs) && extraArgs.length > 0) {
-    args.push(...extraArgs.map(item => String(item)));
-  }
-
-  args.push(normalizedOutputPath);
-  return args;
-}
-
-export async function waitForProcessExit(child, timeoutMs = 5000) {
-  if (!child || child.exitCode !== null) {
-    return {
-      code: child?.exitCode ?? 0,
-      signal: child?.signalCode ?? null,
-      timedOut: false,
-    };
-  }
-
-  return await new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve({
-        code: null,
-        signal: null,
-        timedOut: true,
-      });
-    }, timeoutMs);
-
-    const onExit = (code, signal) => {
-      cleanup();
-      resolve({
-        code,
-        signal,
-        timedOut: false,
-      });
-    };
-
-    const cleanup = () => {
-      clearTimeout(timer);
-      child.removeListener('exit', onExit);
-    };
-
-    child.on('exit', onExit);
-  });
-}
-
-export async function stopFfmpegCapture(runner, {
-  signal = 'SIGINT',
-  timeoutMs = 10000,
-  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;
-}
-
-export async function startFfmpegCapture({
-  display,
-  outputPath,
-  width = DEFAULT_WIDTH,
-  height = DEFAULT_HEIGHT,
-  fps = DEFAULT_FPS,
-  durationSec = null,
-  preset = DEFAULT_PRESET,
-  videoBitrate = DEFAULT_VIDEO_BITRATE,
-  maxRate = DEFAULT_VIDEO_MAX_RATE,
-  bufferSize = DEFAULT_VIDEO_BUFFER_SIZE,
-  logLevel = 'warning',
-  extraArgs = [],
-  startupProbeMs = 1200,
-  ffmpegBin = 'ffmpeg',
-  env = {},
-} = {}) {
-  const normalizedOutputPath = normalizeOutputPath(outputPath);
-  mkdirSync(path.dirname(normalizedOutputPath), { recursive: true });
-
-  const args = buildFfmpegX11grabArgs({
-    display,
-    outputPath: normalizedOutputPath,
-    width,
-    height,
-    fps,
-    durationSec,
-    preset,
-    videoBitrate,
-    maxRate,
-    bufferSize,
-    logLevel,
-    extraArgs,
-  });
-
-  let stdout = '';
-  let stderr = '';
-  let spawnError = null;
-  const child = spawn(ffmpegBin, args, {
-    env: {
-      ...process.env,
-      ...env,
-      DISPLAY: normalizeDisplay(display),
-    },
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    stdout = appendLogChunk(stdout, String(chunk));
-  });
-  child.stderr?.on('data', (chunk) => {
-    stderr = appendLogChunk(stderr, String(chunk));
-  });
-  child.once('error', (error) => {
-    spawnError = error;
-  });
-
-  await new Promise(resolve => setTimeout(resolve, Math.max(0, Number(startupProbeMs) || 0)));
-
-  if (spawnError) {
-    const error = new Error(`ffmpeg_spawn_failed:${spawnError.message}`);
-    error.code = 'FFMPEG_SPAWN_FAILED';
-    throw error;
-  }
-
-  if (child.exitCode !== null) {
-    throw buildExitError({
-      name: 'ffmpeg',
-      code: child.exitCode,
-      signal: child.signalCode,
-      stderr,
-      stdout,
-    });
-  }
-
-  const runner = {
-    child,
-    args,
-    display: normalizeDisplay(display),
-    outputPath: normalizedOutputPath,
-    getStdout: () => stdout,
-    getStderr: () => stderr,
-    waitForExit: (timeoutMs) => waitForProcessExit(child, timeoutMs),
-    stop: (options) => stopFfmpegCapture(runner, options),
-  };
-
-  return runner;
-}
-
-export function createUnexpectedExitWatcher(child, name) {
-  let active = true;
-  const normalizedName = normalizeText(name) || 'process';
-  const promise = new Promise((resolve, reject) => {
-    child.once('exit', (code, signal) => {
-      if (!active) {
-        resolve({ code, signal });
-        return;
-      }
-      reject(buildExitError({
-        name: normalizedName,
-        code,
-        signal,
-      }));
-    });
-    child.once('error', (error) => {
-      if (!active) {
-        resolve({ code: null, signal: null });
-        return;
-      }
-      const wrapped = new Error(`${normalizedName}_spawn_failed:${error.message}`);
-      wrapped.code = `${normalizedName.toUpperCase()}_SPAWN_FAILED`;
-      reject(wrapped);
-    });
-  });
-
-  return {
-    promise,
-    deactivate() {
-      active = false;
-    },
-  };
-}