voxflow 1.15.0 → 1.15.2

package/lib/commands/present.js

@@ -0,0 +1,519 @@
+/**
+ * VoxFlow CLI — Present command
+ *
+ * Converts text or URL content into narrated short-video cards (1080x1920).
+ *
+ * Pipeline:
+ *   1. Input → LLM generates structured card JSON (or user supplies --cards)
+ *   2. Per-card TTS narration synthesis (skipped with --no-audio)
+ *   3. Remotion renders animated card video
+ *   4. FFmpeg merges narration audio into video (if audio exists)
+ *
+ * Requires: remotion-cards/ Remotion project with `npm install` done.
+ * Optional: ffmpeg (for audio merge into MP4).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { PRESENT_DEFAULTS } = require('../core/config');
+const { request, throwApiError, throwNetworkError } = require('../core/http');
+const { buildWav } = require('../core/audio');
+const { BYTES_PER_MS } = require('../core/timeline');
+const { startSpinner } = require('../core/spinner');
+
+// ─── Constants ──────────────────────────────────────────────────────────────
+
+const STYLES = {
+  noir: 'Scheme1-CinematicNoir',
+  neon: 'Scheme2-NeonGlass',
+  editorial: 'Scheme3-EditorialLuxury',
+  aurora: 'Scheme4-GradientAurora',
+  brutalist: 'Scheme5-BoldBrutalist',
+};
+
+const VALID_STYLES = Object.keys(STYLES);
+
+// Deprecated aliases for backward compatibility
+const SCHEMES = STYLES;
+const VALID_SCHEMES = VALID_STYLES;
+
+const DEFAULT_CARD_DURATION_SEC = 10;
+const AUDIO_BUFFER_SEC = 1; // small buffer for crossfade tail when using Remotion <Audio>
+
+// ─── Remotion Discovery ─────────────────────────────────────────────────────
+
+function findVideoPresentDir() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, 'remotion-cards');
+    if (fs.existsSync(path.join(candidate, 'package.json'))) {
+      return candidate;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function isRemotionReady() {
+  const vpDir = findVideoPresentDir();
+  if (!vpDir) return false;
+  return fs.existsSync(path.join(vpDir, 'node_modules', 'remotion'));
+}
+
+// ─── Card Generation via Backend API ──────────────────────────────────────
+
+/**
+ * Generate cards via the backend /api/llm/generate-present-cards endpoint.
+ * This reuses the backend's prompt, JSON parsing, validation, and web search.
+ *
+ * @param {string} apiBase - API base URL
+ * @param {string} token - JWT token
+ * @param {Object} body - { content?, url?, cardCount?, webSearch? }
+ * @returns {{ cards: Object, quota: Object }}
+ */
+async function generateCards(apiBase, token, body) {
+  let status, data;
+  try {
+    ({ status, data } = await request(`${apiBase}/api/llm/generate-present-cards`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      timeoutMs: 180_000,
+    }, body));
+  } catch (err) {
+    throwNetworkError(err, apiBase);
+  }
+
+  if (status !== 200 || data.code !== 'success') {
+    throwApiError(status, data, 'Card generation');
+  }
+
+  return { cards: data.data.cards, quota: data.data.quota };
+}
+
+// ─── TTS Synthesis ──────────────────────────────────────────────────────────
+
+async function synthesizeNarration(apiBase, token, text, voiceId, speed, index, total) {
+  process.stdout.write(`    TTS card [${index + 1}/${total}]...`);
+
+  let status, data;
+  try {
+    ({ status, data } = await request(`${apiBase}/api/tts/synthesize`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+    }, {
+      text,
+      voiceId,
+      speed,
+      volume: 1.0,
+    }));
+  } catch (err) {
+    console.log(' FAIL');
+    throwNetworkError(err, apiBase);
+  }
+
+  if (status !== 200 || data.code !== 'success') {
+    console.log(' FAIL');
+    throwApiError(status, data, `TTS card ${index + 1}`);
+  }
+
+  const pcmBuffer = Buffer.from(data.audio, 'base64');
+  const durationMs = Math.round(pcmBuffer.length / BYTES_PER_MS);
+  console.log(` OK (${(pcmBuffer.length / 1024).toFixed(0)} KB, ${(durationMs / 1000).toFixed(1)}s)`);
+  return { pcm: pcmBuffer, durationMs, quota: data.quota };
+}
+
+// ─── Duration Helpers ───────────────────────────────────────────────────────
+
+function computeDurations(cards, audioTimings) {
+  return cards.map((_card, i) => {
+    if (audioTimings && audioTimings[i] && audioTimings[i].durationMs > 0) {
+      // Card duration = exact audio length + small buffer for crossfade tail, minimum 5s
+      return Math.max(5, Math.ceil(audioTimings[i].durationMs / 1000) + AUDIO_BUFFER_SEC);
+    }
+    return DEFAULT_CARD_DURATION_SEC;
+  });
+}
+
+// ─── Remotion Render ────────────────────────────────────────────────────────
+
+async function renderVideo(cardsData, style, outputPath) {
+  const vpDir = findVideoPresentDir();
+  if (!vpDir) {
+    throw new Error(
+      'remotion-cards/ directory not found.\n' +
+      '    Install: cd remotion-cards && npm install'
+    );
+  }
+
+  if (!fs.existsSync(path.join(vpDir, 'node_modules', 'remotion'))) {
+    throw new Error(
+      'Remotion not installed in remotion-cards/.\n' +
+      '    Run: cd remotion-cards && npm install'
+    );
+  }
+
+  // Hand cards to Remotion via --props (inputProps). Schemes pick it up
+  // through src/loadCardsData.ts, so we no longer have to mutate the
+  // bundled src/data/cards.json (issue #2364). The old write would race
+  // when two `voxflow present` runs overlapped.
+  const propsPath = path.join(
+    require('os').tmpdir(),
+    `voxflow-present-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`
+  );
+  fs.writeFileSync(propsPath, JSON.stringify({ cardsData }));
+
+  const compositionId = STYLES[style] || 'Scheme4-GradientAurora';
+
+  const { execFileSync } = require('child_process');
+  const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+
+  const args = [
+    'remotion', 'render', compositionId, outputPath,
+    '--props', propsPath,
+    '--codec', 'h264',
+    '--image-format', 'jpeg',
+  ];
+
+  try {
+    execFileSync(npxCmd, args, {
+      cwd: vpDir,
+      stdio: 'pipe',
+      timeout: 600_000,
+      maxBuffer: 50 * 1024 * 1024,
+    });
+  } finally {
+    try { fs.unlinkSync(propsPath); } catch { /* non-fatal */ }
+  }
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Generate a short video from text/URL content.
+ *
+ * @param {object} opts
+ * @param {string} opts.token       - JWT token
+ * @param {string} opts.api         - API base URL
+ * @param {string} [opts.text]      - Input text
+ * @param {string} [opts.url]       - URL to fetch content from
+ * @param {string} [opts.cards]     - Path to pre-generated cards.json
+ * @param {string} [opts.style]     - Visual style name
+ * @param {string} [opts.voice]     - TTS voice ID
+ * @param {number} [opts.speed]     - TTS speed
+ * @param {boolean} [opts.noAudio]  - Skip TTS, render video only
+ * @param {string} [opts.output]    - Output file path
+ * @returns {Promise<{outputPath: string, cardsPath: string, duration: number}>}
+ */
+async function present(opts) {
+  const {
+    token,
+    api: apiBase,
+    text: inputText,
+    url: inputUrl,
+    cards: cardsPath,
+    style = PRESENT_DEFAULTS.style,
+    voice = PRESENT_DEFAULTS.voice,
+    speed = PRESENT_DEFAULTS.speed,
+    noAudio = false,
+    webSearch = false,
+  } = opts;
+
+  const sigintHandler = () => {
+    console.log('\n\nGeneration cancelled.');
+    process.exit(130);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  try {
+    const totalSteps = noAudio ? 3 : 4;
+    let stepNum = 1;
+
+    // ── Step 1: Acquire card data ──────────────────────────────────────
+    let cardsData;
+    let llmQuota = null;
+
+    if (cardsPath) {
+      console.log(`\n[${stepNum}/${totalSteps}] Loading cards from ${cardsPath}...`);
+      const raw = fs.readFileSync(cardsPath, 'utf8');
+      try {
+        cardsData = JSON.parse(raw);
+      } catch (err) {
+        throw new Error(`Invalid JSON in cards file ${cardsPath}: ${err.message}`);
+      }
+      if (!cardsData.cards || !Array.isArray(cardsData.cards)) {
+        throw new Error('Invalid cards.json: missing "cards" array');
+      }
+      console.log(`    Loaded ${cardsData.cards.length} cards`);
+    } else {
+      if (inputUrl) {
+        console.log(`\n[${stepNum}/${totalSteps}] Generating cards from URL...`);
+        console.log(`    URL: ${inputUrl}`);
+      } else if (inputText) {
+        console.log(`\n[${stepNum}/${totalSteps}] Generating cards from text...`);
+      } else {
+        throw new Error('No input provided. Use --text, --url, or --cards');
+      }
+      if (webSearch) console.log('    Web search: enabled');
+
+      const body = {};
+      if (inputUrl) body.url = inputUrl;
+      else body.content = inputText;
+      if (webSearch) body.webSearch = true;
+
+      const spinner = startSpinner('    Generating via API...');
+      try {
+        const result = await generateCards(apiBase, token, body);
+        cardsData = result.cards;
+        llmQuota = result.quota;
+        spinner.stop(`OK (${cardsData.cards.length} cards)`);
+      } catch (err) {
+        spinner.stop('FAIL');
+        throw new Error(`Card generation failed: ${err.message}`);
+      }
+    }
+
+    const cardCount = cardsData.cards.length;
+    const types = cardsData.cards.map(c => c.type).join(', ');
+    console.log(`    Cards: ${cardCount} (${types})`);
+
+    stepNum++;
+
+    // ── Step 2: TTS narration (optional) ───────────────────────────────
+    let audioTimings = null;
+    let firstQuota = llmQuota;
+    let lastQuota = llmQuota;
+    const vpDir = findVideoPresentDir();
+    const audioFileNames = []; // per-card WAV filenames written to public/
+
+    if (!noAudio) {
+      const narrations = cardsData.cards.filter(c => c.narration);
+      console.log(`\n[${stepNum}/${totalSteps}] Synthesizing narration (${narrations.length} cards with narration)...`);
+
+      audioTimings = [];
+
+      for (let i = 0; i < cardsData.cards.length; i++) {
+        const card = cardsData.cards[i];
+        if (!card.narration) {
+          audioTimings.push({ durationMs: 0 });
+          audioFileNames.push(null);
+          continue;
+        }
+
+        const result = await synthesizeNarration(
+          apiBase, token, card.narration, voice, speed, i, cardCount
+        );
+        audioTimings.push({ durationMs: result.durationMs });
+        if (!firstQuota && result.quota) firstQuota = result.quota;
+        lastQuota = result.quota;
+
+        // Write per-card WAV to remotion-cards/public/ so Remotion <Audio> can serve it
+        const audioFileName = `card-narration-${i}.wav`;
+        if (vpDir) {
+          const publicDir = path.join(vpDir, 'public');
+          fs.mkdirSync(publicDir, { recursive: true });
+          const wav = buildWav([result.pcm], 0);
+          fs.writeFileSync(path.join(publicDir, audioFileName), wav.wav);
+        }
+        audioFileNames.push(audioFileName);
+      }
+
+      stepNum++;
+    }
+
+    // Embed per-card audio filename and duration into cardsData for Remotion
+    const durationsSec = computeDurations(cardsData.cards, audioTimings);
+    cardsData.cards = cardsData.cards.map((card, i) => ({
+      ...card,
+      durationSec: durationsSec[i],
+      audioFile: audioFileNames[i] || null,
+    }));
+
+    // ── Step 3: Render video ───────────────────────────────────────────
+    console.log(`\n[${stepNum}/${totalSteps}] Rendering video (style: ${style})...`);
+
+    if (!isRemotionReady()) {
+      // Fallback: save cards JSON + per-card WAV paths so the user can render later
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const cardsOutPath = `present-${timestamp}.json`;
+      fs.writeFileSync(cardsOutPath, JSON.stringify(cardsData, null, 2));
+      console.log('    Remotion not available. Saved cards & audio for later rendering.');
+      console.log(`    Cards:  ${cardsOutPath}`);
+      if (audioFileNames.some(Boolean) && vpDir) {
+        audioFileNames.filter(Boolean).forEach(f => {
+          console.log(`    Audio:  ${path.join(vpDir, 'public', f)}`);
+        });
+      }
+      console.log('\n    To install Remotion: cd remotion-cards && npm install');
+      console.log('    Then re-run with: voxflow present --cards ' + cardsOutPath);
+      const totalDurationMs = durationsSec.reduce((s, d) => s + d * 1000, 0);
+      return { outputPath: null, cardsPath: cardsOutPath, duration: totalDurationMs };
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const videoPath = opts.output || `present-${timestamp}.mp4`;
+
+    const spinner = startSpinner('    Rendering...');
+    try {
+      // Remotion <Audio> components handle sync natively — no FFmpeg merge needed
+      await renderVideo(cardsData, style, videoPath);
+      spinner.stop('OK');
+    } catch (err) {
+      spinner.stop('FAIL');
+      try { fs.unlinkSync(videoPath); } catch { /* ignore */ }
+      throw new Error(`Video render failed: ${err.message}`);
+    } finally {
+      // Clean up per-card audio files from public/
+      if (vpDir) {
+        audioFileNames.forEach(f => {
+          if (f) try { fs.unlinkSync(path.join(vpDir, 'public', f)); } catch { /* ignore */ }
+        });
+      }
+    }
+
+    stepNum++;
+
+    // ── Final: Save cards & summary ────────────────────────────────────
+    const cardsOutPath = videoPath.replace(/\.mp4$/, '.json');
+    fs.writeFileSync(cardsOutPath, JSON.stringify(cardsData, null, 2));
+
+    const totalDurationMs = durationsSec.reduce((s, d) => s + d * 1000, 0);
+    const fileStat = fs.statSync(videoPath);
+    const fileSizeMb = (fileStat.size / (1024 * 1024)).toFixed(1);
+
+    console.log(`\n[${stepNum}/${totalSteps}] Done!`);
+    console.log('\n=== Output ===');
+    console.log(`  Video:    ${videoPath} (${fileSizeMb} MB, ${formatDuration(totalDurationMs)})`);
+    console.log(`  Cards:    ${cardsOutPath}`);
+    console.log(`  Style:    ${style}`);
+    console.log(`  Cards:    ${cardCount} (${types})`);
+    if (lastQuota) {
+      const quotaUsed = firstQuota && lastQuota
+        ? (firstQuota.remaining - lastQuota.remaining)
+        : cardCount * 100;
+      console.log(`  Quota:    ${quotaUsed} used, ${lastQuota.remaining ?? '?'} remaining`);
+    }
+
+    return { outputPath: videoPath, cardsPath: cardsOutPath, duration: totalDurationMs };
+  } finally {
+    process.removeListener('SIGINT', sigintHandler);
+  }
+}
+
+function formatDuration(ms) {
+  const totalSec = Math.round(ms / 1000);
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  if (min === 0) return `${sec}s`;
+  return `${min}m${sec.toString().padStart(2, '0')}s`;
+}
+
+// ─── CLI Handler ────────────────────────────────────────────────────────────
+
+async function handle(args) {
+  const { parseFlag, parseFloatFlag, parseBoolFlag, validateSpeed, runWithRetry } = require('../core/args');
+  const { getToken, getTokenInfo } = require('../core/auth');
+  const { API_BASE } = require('../core/config');
+
+  const api = parseFlag(args, '--api') || API_BASE;
+  const explicitToken = parseFlag(args, '--token');
+
+  // Validate flags before auth
+  const speed = parseFloatFlag(args, '--speed');
+  const output = parseFlag(args, '--output', '-o');
+
+  validateSpeed(args, speed);
+
+  if (output) {
+    const hasValidExt = ['.mp4', '.wav'].some(ext => output.toLowerCase().endsWith(ext));
+    if (!hasValidExt) {
+      console.error('Error: --output path must end with .mp4 or .wav');
+      process.exit(1);
+    }
+  }
+
+  const style = parseFlag(args, '--style') || parseFlag(args, '--scheme'); // --scheme is deprecated alias
+  if (style && !VALID_STYLES.includes(style)) {
+    console.error(`Error: --style must be one of: ${VALID_STYLES.join(', ')} (got: "${style}")`);
+    process.exit(1);
+  }
+
+  // Require at least one input
+  const text = parseFlag(args, '--text');
+  const url = parseFlag(args, '--url');
+  const cards = parseFlag(args, '--cards');
+  if (!text && !url && !cards) {
+    console.error('Error: provide one of --text, --url, or --cards');
+    process.exit(1);
+  }
+
+  if (cards && !require('fs').existsSync(cards)) {
+    console.error(`Error: cards file not found: ${cards}`);
+    process.exit(1);
+  }
+
+  // Auth after validation
+  let token;
+  if (explicitToken) {
+    token = explicitToken;
+  } else {
+    token = await getToken({ api });
+    const info = getTokenInfo();
+    if (info) {
+      console.log(`\x1b[32mLogged in as ${info.email}\x1b[0m`);
+    }
+  }
+
+  const opts = {
+    token, api,
+    text, url, cards,
+    style: style || undefined,
+    voice: parseFlag(args, '--voice') || undefined,
+    speed, output,
+    noAudio: parseBoolFlag(args, '--no-audio'),
+    webSearch: parseBoolFlag(args, '--web-search'),
+  };
+
+  await runWithRetry(present, opts, api, explicitToken);
+}
+
+const meta = {
+  present: {
+    usage: '<--text|--url|--cards> [opts]',
+    description: 'Generate a short video from text or URL content',
+    options: [
+      `--text <text>        Input text content`,
+      `--url <url>          URL to fetch and convert`,
+      `--cards <path>       Pre-generated cards.json (skip LLM)`,
+      `--style <name>       Visual style: noir, neon, editorial, aurora (default), brutalist`,
+      `--voice <id>         TTS voice ID (default: ${PRESENT_DEFAULTS.voice})`,
+      `--speed <n>          TTS speed 0.5-2.0 (default: ${PRESENT_DEFAULTS.speed})`,
+      `--no-audio           Skip TTS, render silent video only`,
+      `--web-search         Search the web for up-to-date info on the topic`,
+      `--output <path>      Output file path (default: ./present-<timestamp>.mp4)`,
+    ],
+    examples: [
+      'voxflow present --text "Claude Code 是一个 AI 编程工具" --style aurora',
+      'voxflow present --url https://example.com/article --style noir',
+      'voxflow present --text "2025 AI芯片格局" --web-search --style neon',
+      'voxflow present --cards my-cards.json --no-audio',
+      'voxflow present --text "React 入门指南" --voice v-male-Bk7vD3xP --output react.mp4',
+    ],
+  },
+};
+
+module.exports = {
+  present, handle, meta,
+  STYLES, VALID_STYLES,
+  // Deprecated aliases (backward compat)
+  SCHEMES, VALID_SCHEMES,
+  // Shared utilities for video rendering (used by summarize --video)
+  renderVideo, findVideoPresentDir, isRemotionReady,
+  computeDurations, synthesizeNarration,
+  _test: { computeDurations, formatDuration, STYLES, VALID_STYLES, SCHEMES, VALID_SCHEMES },
+};