@lightcone-ai/daemon 0.15.43 → 0.15.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.43",
+  "version": "0.15.45",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/composer-v2/index.js

@@ -0,0 +1,285 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { mkdir, rm, writeFile, access } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+const DEFAULT_WIDTH = 1080;
+const DEFAULT_HEIGHT = 1920;
+const DEFAULT_FPS = 30;
+const TRANSITION_DURATION = 0.5;
+
+async function fileExists(p) {
+  try { await access(p, fsConstants.R_OK); return true; } catch { return false; }
+}
+
+async function runFfmpeg(args, label = 'ffmpeg') {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ffmpeg', ['-y', ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+    const stderr = [];
+    proc.stderr.on('data', chunk => stderr.push(chunk));
+    proc.on('close', code => {
+      if (code === 0) return resolve();
+      const msg = Buffer.concat(stderr).toString().slice(-3000);
+      reject(new Error(`${label} exited ${code}:\n${msg}`));
+    });
+    proc.on('error', err => reject(new Error(`${label} spawn failed: ${err.message}`)));
+  });
+}
+
+async function probeDurationSec(inputPath) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ffprobe', [
+      '-v', 'error',
+      '-select_streams', 'v:0',
+      '-show_entries', 'stream=duration',
+      '-of', 'csv=p=0',
+      inputPath,
+    ], { stdio: ['ignore', 'pipe', 'pipe'] });
+    const out = [];
+    proc.stdout.on('data', c => out.push(c));
+    proc.on('close', code => {
+      if (code !== 0) return reject(new Error(`ffprobe failed on ${inputPath}`));
+      const val = parseFloat(Buffer.concat(out).toString().trim());
+      resolve(Number.isFinite(val) ? val : 3);
+    });
+    proc.on('error', reject);
+  });
+}
+
+async function imageToClip({ imagePath, duration, style, tmpDir, width, height, fps }) {
+  const outPath = path.join(tmpDir, `clip-img-${randomUUID().slice(0, 8)}.mp4`);
+  if (style === 'scroll') {
+    const imgH = await probeDurationSec(imagePath).catch(() => height * 4);
+    const actualImgH = Math.round(Number.isFinite(imgH) ? imgH : height * 4);
+    const scrollFilter = `[0:v]scale=${width}:-1,crop=${width}:${height}:0:'if(gte(t*${actualImgH - height}/${duration},${actualImgH - height}),${actualImgH - height},t*${actualImgH - height}/${duration})'[v]`;
+    await runFfmpeg([
+      '-loop', '1', '-t', String(duration), '-i', imagePath,
+      '-filter_complex', scrollFilter,
+      '-map', '[v]',
+      '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-r', String(fps),
+      '-movflags', '+faststart',
+      outPath,
+    ], 'ffmpeg scroll');
+  } else {
+    await runFfmpeg([
+      '-loop', '1', '-t', String(duration), '-i', imagePath,
+      '-vf', `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1`,
+      '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-r', String(fps),
+      '-movflags', '+faststart',
+      outPath,
+    ], 'ffmpeg image-to-clip');
+  }
+  return { path: outPath, duration };
+}
+
+async function gifToClip({ gifPath, duration, tmpDir, width, height, fps }) {
+  const naturalDuration = await probeDurationSec(gifPath).catch(() => 3);
+  const clipDuration = duration ?? naturalDuration;
+  const outPath = path.join(tmpDir, `clip-gif-${randomUUID().slice(0, 8)}.mp4`);
+  const loopCount = duration ? Math.ceil(duration / naturalDuration) : 1;
+  await runFfmpeg([
+    '-stream_loop', String(loopCount),
+    '-i', gifPath,
+    '-t', String(clipDuration),
+    '-vf', `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1`,
+    '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-r', String(fps),
+    '-movflags', '+faststart',
+    outPath,
+  ], 'ffmpeg gif-to-clip');
+  return { path: outPath, duration: clipDuration };
+}
+
+async function videoToClip({ videoPath, duration, tmpDir, width, height, fps }) {
+  const outPath = path.join(tmpDir, `clip-vid-${randomUUID().slice(0, 8)}.mp4`);
+  const vf = `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1`;
+  const durationArgs = duration ? ['-t', String(duration)] : [];
+  await runFfmpeg([
+    '-i', videoPath, ...durationArgs,
+    '-vf', vf,
+    '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-r', String(fps),
+    '-c:a', 'aac',
+    '-movflags', '+faststart',
+    outPath,
+  ], 'ffmpeg video-to-clip');
+  const actualDuration = duration ?? await probeDurationSec(outPath);
+  return { path: outPath, duration: actualDuration };
+}
+
+async function muxAudio({ videoPath, audioPath, duration, tmpDir }) {
+  const outPath = path.join(tmpDir, `muxed-${randomUUID().slice(0, 8)}.mp4`);
+  await runFfmpeg([
+    '-i', videoPath,
+    '-i', audioPath,
+    '-map', '0:v:0',
+    '-map', '1:a:0',
+    '-c:v', 'copy',
+    '-c:a', 'aac',
+    '-shortest',
+    '-t', String(duration),
+    outPath,
+  ], 'ffmpeg mux-audio');
+  return outPath;
+}
+
+async function silentClip({ videoPath, duration, tmpDir }) {
+  const outPath = path.join(tmpDir, `silent-${randomUUID().slice(0, 8)}.mp4`);
+  await runFfmpeg([
+    '-i', videoPath,
+    '-f', 'lavfi', '-i', `anullsrc=channel_layout=stereo:sample_rate=44100`,
+    '-map', '0:v:0',
+    '-map', '1:a:0',
+    '-c:v', 'copy',
+    '-c:a', 'aac',
+    '-shortest',
+    '-t', String(duration),
+    outPath,
+  ], 'ffmpeg silent-audio');
+  return outPath;
+}
+
+async function concatWithCuts({ clips, outputPath }) {
+  const listPath = outputPath + '.concat.txt';
+  const listContent = clips.map(c => `file '${c}'`).join('\n');
+  await writeFile(listPath, listContent);
+  try {
+    await runFfmpeg([
+      '-f', 'concat', '-safe', '0', '-i', listPath,
+      '-c', 'copy',
+      '-movflags', '+faststart',
+      outputPath,
+    ], 'ffmpeg concat');
+  } finally {
+    await rm(listPath, { force: true });
+  }
+}
+
+async function applyFadeTransition({ clipA, clipB, tmpDir, style = 'fade' }) {
+  const xfadeMode = style === 'crossfade' ? 'dissolve' : 'fade';
+  const durA = await probeDurationSec(clipA);
+  const offset = Math.max(0, durA - TRANSITION_DURATION);
+  const outPath = path.join(tmpDir, `xfade-${randomUUID().slice(0, 8)}.mp4`);
+  await runFfmpeg([
+    '-i', clipA,
+    '-i', clipB,
+    '-filter_complex',
+    `[0:v][1:v]xfade=transition=${xfadeMode}:duration=${TRANSITION_DURATION}:offset=${offset}[v];` +
+    `[0:a][1:a]acrossfade=d=${TRANSITION_DURATION}[a]`,
+    '-map', '[v]', '-map', '[a]',
+    '-c:v', 'libx264', '-pix_fmt', 'yuv420p',
+    '-c:a', 'aac',
+    '-movflags', '+faststart',
+    outPath,
+  ], 'ffmpeg xfade');
+  return outPath;
+}
+
+export async function composeVideoV2({
+  segments = [],
+  outro_paths = [],
+  resolution = '1080x1920',
+  output_path,
+}) {
+  if (!Array.isArray(segments) || segments.length === 0) {
+    throw new Error('segments must be a non-empty array');
+  }
+
+  const [widthStr, heightStr] = String(resolution).split('x');
+  const width = parseInt(widthStr, 10) || DEFAULT_WIDTH;
+  const height = parseInt(heightStr, 10) || DEFAULT_HEIGHT;
+  const fps = DEFAULT_FPS;
+
+  const tmpDir = path.join(os.tmpdir(), `compose-v2-${randomUUID().slice(0, 8)}`);
+  await mkdir(tmpDir, { recursive: true });
+
+  const outPath = output_path ?? path.join(os.tmpdir(), `lightcone-video-${Date.now()}.mp4`);
+  await mkdir(path.dirname(outPath), { recursive: true });
+
+  try {
+    const readyClips = [];
+
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      const kind = String(seg.visual_kind ?? 'image');
+      const presentation = seg.presentation ?? {};
+      const style = String(presentation.style ?? 'static');
+      const duration = Number(presentation.duration ?? presentation.per_card_duration ?? 4);
+      const audioPath = seg.audio_path ?? null;
+      const transition = String(seg.transition ?? 'cut');
+
+      let visualClip;
+
+      if (kind === 'image') {
+        const imgPath = String(seg.visual_path ?? '');
+        if (!imgPath) throw new Error(`segments[${i}]: visual_path required for kind=image`);
+        visualClip = await imageToClip({ imagePath: imgPath, duration, style, tmpDir, width, height, fps });
+      } else if (kind === 'carousel') {
+        const paths = Array.isArray(seg.visual_paths) ? seg.visual_paths : [];
+        if (paths.length === 0) throw new Error(`segments[${i}]: visual_paths required for kind=carousel`);
+        const perCard = Number(presentation.per_card_duration ?? 3);
+        const cardClips = [];
+        for (const p of paths) {
+          const c = await imageToClip({ imagePath: p, duration: perCard, style: 'static', tmpDir, width, height, fps });
+          cardClips.push(c.path);
+        }
+        const carouselOut = path.join(tmpDir, `carousel-${randomUUID().slice(0, 8)}.mp4`);
+        await concatWithCuts({ clips: cardClips, outputPath: carouselOut });
+        visualClip = { path: carouselOut, duration: perCard * paths.length };
+      } else if (kind === 'gif') {
+        const gifPath = String(seg.visual_path ?? '');
+        if (!gifPath) throw new Error(`segments[${i}]: visual_path required for kind=gif`);
+        visualClip = await gifToClip({ gifPath, duration: presentation.duration ?? null, tmpDir, width, height, fps });
+      } else if (kind === 'video') {
+        const vidPath = String(seg.visual_path ?? '');
+        if (!vidPath) throw new Error(`segments[${i}]: visual_path required for kind=video`);
+        visualClip = await videoToClip({ videoPath: vidPath, duration: presentation.duration ?? null, tmpDir, width, height, fps });
+      } else {
+        throw new Error(`segments[${i}]: unknown visual_kind "${kind}"`);
+      }
+
+      let finalClip;
+      if (audioPath && await fileExists(audioPath)) {
+        finalClip = await muxAudio({ videoPath: visualClip.path, audioPath, duration: visualClip.duration, tmpDir });
+      } else {
+        finalClip = await silentClip({ videoPath: visualClip.path, duration: visualClip.duration, tmpDir });
+      }
+
+      readyClips.push({ path: finalClip, duration: visualClip.duration, transition });
+    }
+
+    const outroClips = [];
+    for (const outroPath of (outro_paths ?? [])) {
+      if (outroPath && await fileExists(outroPath)) {
+        const c = await videoToClip({ videoPath: outroPath, tmpDir, width, height, fps });
+        outroClips.push(c.path);
+      }
+    }
+
+    const allClips = [];
+    let accumulated = readyClips[0].path;
+    for (let i = 1; i < readyClips.length; i++) {
+      const { path: nextClip, transition } = readyClips[i];
+      if (transition === 'fade' || transition === 'crossfade') {
+        accumulated = await applyFadeTransition({ clipA: accumulated, clipB: nextClip, tmpDir, style: transition });
+      } else {
+        allClips.push(accumulated);
+        accumulated = nextClip;
+      }
+    }
+    allClips.push(accumulated);
+
+    const finalSequence = [...allClips, ...outroClips];
+
+    if (finalSequence.length === 1) {
+      await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', outPath], 'ffmpeg copy');
+    } else {
+      await concatWithCuts({ clips: finalSequence, outputPath: outPath });
+    }
+
+    const totalDuration = await probeDurationSec(outPath);
+    return { path: outPath, duration_ms: Math.round(totalDuration * 1000) };
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}

package/src/_vendor/video/text-renderer/index.js

@@ -0,0 +1,103 @@
+import { readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = path.join(__dirname, 'templates');
+
+const THEMES = {
+  dark:  { bg: '#1a1a1a', text: '#f0f0f0' },
+  light: { bg: '#ffffff', text: '#1a1a1a' },
+};
+
+function escapeHtml(str) {
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function renderTemplate(templateName, vars) {
+  let html = readFileSync(path.join(TEMPLATES_DIR, templateName), 'utf8');
+  for (const [key, value] of Object.entries(vars)) {
+    html = html.replaceAll(`{{${key}}}`, value);
+  }
+  return html;
+}
+
+async function launchBrowser() {
+  let playwright;
+  try {
+    playwright = await import('playwright');
+  } catch {
+    throw new Error('playwright_import_failed: run npm install playwright');
+  }
+  return playwright.chromium.launch({ headless: true });
+}
+
+export async function renderTextToImages({
+  content,
+  style = 'scroll',
+  theme = 'dark',
+  width = 1080,
+  cardHeight = 1920,
+  fontSize = 48,
+  outputDir,
+}) {
+  const colors = THEMES[theme] ?? THEMES.dark;
+  const outDir = outputDir ?? path.join(os.tmpdir(), `text-render-${randomUUID().slice(0, 8)}`);
+  mkdirSync(outDir, { recursive: true });
+
+  const browser = await launchBrowser();
+  try {
+    if (style === 'scroll') {
+      const items = Array.isArray(content) ? content.join('\n\n') : String(content);
+      const html = renderTemplate('scroll.html', {
+        WIDTH: width,
+        BG_COLOR: colors.bg,
+        TEXT_COLOR: colors.text,
+        FONT_SIZE: fontSize,
+        CONTENT: escapeHtml(items),
+      });
+      const page = await browser.newPage();
+      await page.setViewportSize({ width, height: cardHeight });
+      await page.setContent(html, { waitUntil: 'load' });
+      const bodyHeight = await page.evaluate(() => document.body.scrollHeight);
+      await page.setViewportSize({ width, height: bodyHeight });
+      const outPath = path.join(outDir, 'scroll.png');
+      await page.screenshot({ path: outPath, fullPage: false });
+      await page.close();
+      return [outPath];
+    }
+
+    if (style === 'carousel') {
+      const items = Array.isArray(content) ? content : [String(content)];
+      const paths = [];
+      for (let i = 0; i < items.length; i++) {
+        const html = renderTemplate('carousel.html', {
+          WIDTH: width,
+          HEIGHT: cardHeight,
+          BG_COLOR: colors.bg,
+          TEXT_COLOR: colors.text,
+          FONT_SIZE: fontSize,
+          CONTENT: escapeHtml(items[i]),
+        });
+        const page = await browser.newPage();
+        await page.setViewportSize({ width, height: cardHeight });
+        await page.setContent(html, { waitUntil: 'load' });
+        const outPath = path.join(outDir, `card-${String(i).padStart(3, '0')}.png`);
+        await page.screenshot({ path: outPath });
+        await page.close();
+        paths.push(outPath);
+      }
+      return paths;
+    }
+
+    throw new Error(`unsupported_style: ${style}`);
+  } finally {
+    await browser.close();
+  }
+}

package/src/_vendor/video/text-renderer/templates/carousel.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body {
+    width: {{WIDTH}}px;
+    height: {{HEIGHT}}px;
+    background: {{BG_COLOR}};
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    overflow: hidden;
+  }
+  .card {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 80px 70px;
+  }
+  .text {
+    font-family: -apple-system, "PingFang SC", "Noto Sans CJK SC", "Microsoft YaHei", sans-serif;
+    color: {{TEXT_COLOR}};
+    font-size: {{FONT_SIZE}}px;
+    line-height: 1.85;
+    letter-spacing: 0.02em;
+    word-break: break-all;
+    overflow-wrap: break-word;
+    white-space: pre-wrap;
+    text-align: center;
+  }
+</style>
+</head>
+<body>
+  <div class="card">
+    <div class="text">{{CONTENT}}</div>
+  </div>
+</body>
+</html>

package/src/_vendor/video/text-renderer/templates/scroll.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body { width: {{WIDTH}}px; background: {{BG_COLOR}}; }
+  body {
+    font-family: -apple-system, "PingFang SC", "Noto Sans CJK SC", "Microsoft YaHei", sans-serif;
+    color: {{TEXT_COLOR}};
+    padding: 80px 60px 80px 60px;
+    font-size: {{FONT_SIZE}}px;
+    line-height: 1.85;
+    letter-spacing: 0.02em;
+    word-break: break-all;
+    overflow-wrap: break-word;
+    white-space: pre-wrap;
+  }
+</style>
+</head>
+<body>{{CONTENT}}</body>
+</html>

package/src/tools/compose-video-v2.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import os from 'os';
 import { randomUUID } from 'crypto';
-import { composeVideoV2 } from '../../../src/video/composer-v2/index.js';
+import { composeVideoV2 } from '../_vendor/video/composer-v2/index.js';
 
 function toolText(text) {
   return { content: [{ type: 'text', text }] };

package/src/tools/render-text-to-image.js

@@ -1,4 +1,4 @@
-import { renderTextToImages } from '../../../src/video/text-renderer/index.js';
+import { renderTextToImages } from '../_vendor/video/text-renderer/index.js';
 
 function toolText(text) {
   return { content: [{ type: 'text', text }] };