edsger 0.77.0 → 0.78.0

package/dist/services/video/screenshot-generator.js

@@ -1,259 +0,0 @@
-/**
- * Screenshot generator for growth video content.
- * Uses Playwright to capture screenshots of the product's web application
- * with mock data injected for realistic demo scenarios.
- */
-import { mkdir, readFile } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { ensurePlaywright } from '../../utils/validation.js';
-import { generateDeviceFrameHtml, } from './device-frames.js';
-/**
- * Dynamically load Playwright's chromium launcher.
- * Returns null if Playwright is not installed.
- */
-async function loadChromium() {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-new-func -- dynamic import to avoid bundler resolution of optional peer dependency
-        const pw = await Function('return import("playwright")')();
-        return pw.chromium;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Check if Playwright is available
- */
-export async function isPlaywrightAvailable() {
-    const chromium = await loadChromium();
-    return chromium !== null;
-}
-/**
- * Get a unique temporary directory for a single video generation run.
- * Each call returns a distinct path to avoid race conditions when
- * multiple videos are generated concurrently for the same product.
- */
-export function getVideoTempDir(productId) {
-    const uniqueId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    return join(tmpdir(), 'edsger-growth-videos', productId, uniqueId);
-}
-/**
- * Auto-detect device frame type based on viewport dimensions.
- * Mobile aspect ratios get iPhone frame, desktop gets browser frame.
- */
-function autoDetectDeviceFrame(width, height) {
-    const aspectRatio = width / height;
-    if (aspectRatio < 0.7) {
-        return 'iphone'; // portrait mobile
-    }
-    return 'browser'; // landscape desktop
-}
-/**
- * Wrap a screenshot PNG in a device frame by rendering the frame HTML with
- * the screenshot embedded as a data URL, then capturing the result.
- * Reuses a shared browser instance to avoid spawning a new process per scene.
- */
-async function applyDeviceFrame(screenshotPath, scene, browser, verbose) {
-    const frameType = scene.deviceFrame ||
-        autoDetectDeviceFrame(scene.viewportWidth || 1280, scene.viewportHeight || 720);
-    if (frameType === 'none') {
-        return screenshotPath; // no framing requested
-    }
-    // Read the screenshot and convert to data URL
-    const screenshotBuffer = await readFile(screenshotPath);
-    const dataUrl = `data:image/png;base64,${screenshotBuffer.toString('base64')}`;
-    // Generate the frame HTML
-    const frameHtml = generateDeviceFrameHtml(dataUrl, frameType, {
-        background: scene.frameBackground,
-        browserUrl: scene.frameBrowserUrl,
-        shadow: true,
-    });
-    // Determine frame output dimensions
-    const frameWidth = frameType === 'iphone' ? 800 : 1600;
-    const frameHeight = frameType === 'iphone' ? 1200 : 1000;
-    // Reuse the shared browser — create a temporary context for this frame
-    const context = await browser.newContext({
-        viewport: { width: frameWidth, height: frameHeight },
-        deviceScaleFactor: 2,
-    });
-    try {
-        const page = await context.newPage();
-        await page.setContent(frameHtml, { waitUntil: 'load' });
-        await page.waitForTimeout(300);
-        const framedPath = screenshotPath.replace('.png', '-framed.png');
-        await page.screenshot({
-            path: framedPath,
-            fullPage: false,
-            type: 'png',
-        });
-        if (verbose) {
-            logInfo(`  Applied ${frameType} device frame`);
-        }
-        return framedPath;
-    }
-    finally {
-        await context.close();
-    }
-}
-/**
- * Capture screenshots for all scenes using Playwright.
- * Requires Playwright to be installed: npm install playwright
- */
-export async function captureScreenshots(scenes, options, verbose) {
-    await ensurePlaywright(isPlaywrightAvailable);
-    const chromium = await loadChromium();
-    if (!chromium) {
-        throw new Error('Failed to load chromium');
-    }
-    const { baseUrl, outputDir, viewportWidth = 1280, viewportHeight = 720, fullPage = false, } = options;
-    // Ensure output directory exists
-    await mkdir(outputDir, { recursive: true });
-    if (verbose) {
-        logInfo(`Capturing ${scenes.length} screenshots from ${baseUrl}`);
-    }
-    const browser = await chromium.launch({
-        headless: true,
-        args: ['--no-sandbox', '--disable-setuid-sandbox'],
-    });
-    const capturedScenes = [];
-    try {
-        const context = await browser.newContext({
-            viewport: {
-                width: viewportWidth,
-                height: viewportHeight,
-            },
-            deviceScaleFactor: 2, // Retina quality
-        });
-        const page = await context.newPage();
-        // Sort scenes by order
-        const sortedScenes = [...scenes].sort((a, b) => a.order - b.order);
-        for (const scene of sortedScenes) {
-            try {
-                const sceneViewport = {
-                    width: scene.viewportWidth || viewportWidth,
-                    height: scene.viewportHeight || viewportHeight,
-                };
-                await page.setViewportSize(sceneViewport);
-                const url = `${baseUrl}${scene.pagePath}`;
-                if (verbose) {
-                    logInfo(`Scene ${scene.order}: Navigating to ${url}`);
-                }
-                await page.goto(url, {
-                    waitUntil: 'networkidle',
-                    timeout: 30000,
-                });
-                // Execute setup script if provided (for mock data injection)
-                if (scene.setupScript) {
-                    logInfo(`Scene ${scene.order}: Executing setup script`);
-                    await page.evaluate(scene.setupScript);
-                    // Wait for any DOM updates after script execution
-                    await page.waitForTimeout(500);
-                }
-                // Wait for specific selector if provided
-                if (scene.waitForSelector) {
-                    await page.waitForSelector(scene.waitForSelector, {
-                        timeout: 10000,
-                    });
-                }
-                // Small delay for any animations to settle
-                await page.waitForTimeout(300);
-                // Capture screenshot
-                const rawPath = join(outputDir, `scene-${String(scene.order).padStart(3, '0')}.png`);
-                await page.screenshot({
-                    path: rawPath,
-                    fullPage,
-                    type: 'png',
-                });
-                // Apply device frame (reuse the existing browser instance)
-                const screenshotPath = await applyDeviceFrame(rawPath, scene, browser, verbose);
-                capturedScenes.push({
-                    ...scene,
-                    screenshotPath,
-                });
-                if (verbose) {
-                    logInfo(`Scene ${scene.order}: Screenshot saved to ${screenshotPath}`);
-                }
-            }
-            catch (error) {
-                logError(`Failed to capture scene ${scene.order}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        await context.close();
-    }
-    finally {
-        await browser.close();
-    }
-    if (capturedScenes.length === 0) {
-        throw new Error('No screenshots were captured successfully');
-    }
-    logInfo(`Captured ${capturedScenes.length}/${scenes.length} screenshots`);
-    return capturedScenes;
-}
-/**
- * Generate screenshots using static HTML rendering (fallback when no running app).
- * Creates screenshots from pre-built HTML templates with mock data.
- */
-export async function captureStaticScreenshots(scenes, outputDir, htmlTemplates, verbose) {
-    await ensurePlaywright(isPlaywrightAvailable);
-    const chromium = await loadChromium();
-    if (!chromium) {
-        throw new Error('Failed to load chromium');
-    }
-    await mkdir(outputDir, { recursive: true });
-    if (verbose) {
-        logInfo(`Rendering ${scenes.length} static HTML scenes`);
-    }
-    const browser = await chromium.launch({
-        headless: true,
-        args: ['--no-sandbox', '--disable-setuid-sandbox'],
-    });
-    const capturedScenes = [];
-    try {
-        const context = await browser.newContext({
-            viewport: { width: 1280, height: 720 },
-            deviceScaleFactor: 2,
-        });
-        const page = await context.newPage();
-        const sortedScenes = [...scenes].sort((a, b) => a.order - b.order);
-        for (let i = 0; i < sortedScenes.length; i++) {
-            const scene = sortedScenes[i];
-            const html = htmlTemplates[i];
-            if (!html) {
-                logWarning(`No HTML template for scene ${scene.order}, skipping`);
-                continue;
-            }
-            try {
-                const viewport = {
-                    width: scene.viewportWidth || 1280,
-                    height: scene.viewportHeight || 720,
-                };
-                await page.setViewportSize(viewport);
-                await page.setContent(html, { waitUntil: 'networkidle' });
-                await page.waitForTimeout(500);
-                const rawPath = join(outputDir, `scene-${String(scene.order).padStart(3, '0')}.png`);
-                await page.screenshot({
-                    path: rawPath,
-                    fullPage: false,
-                    type: 'png',
-                });
-                // Apply device frame (reuse the existing browser instance)
-                const screenshotPath = await applyDeviceFrame(rawPath, scene, browser, verbose);
-                capturedScenes.push({ ...scene, screenshotPath });
-                if (verbose) {
-                    logInfo(`Scene ${scene.order}: Static screenshot saved`);
-                }
-            }
-            catch (error) {
-                logError(`Failed to render scene ${scene.order}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        await context.close();
-    }
-    finally {
-        await browser.close();
-    }
-    logInfo(`Rendered ${capturedScenes.length}/${scenes.length} static screenshots`);
-    return capturedScenes;
-}

package/dist/services/video/tts-generator.d.ts

@@ -1,40 +0,0 @@
-/**
- * Text-to-Speech generator for growth video narration.
- * Supports ElevenLabs (primary) and Deepgram (fallback) for professional voiceovers.
- */
-export interface TTSOptions {
-    /** TTS provider to use */
-    provider: 'elevenlabs' | 'deepgram';
-    /** API key for the selected provider */
-    apiKey: string;
-    /** Voice ID or name */
-    voiceId?: string;
-    /** Output directory for audio files */
-    outputDir: string;
-    /** Language code (default: 'en') */
-    language?: string;
-    /** Speaking speed multiplier (default: 1.0) */
-    speed?: number;
-}
-export interface GeneratedAudio {
-    /** Scene order number */
-    sceneOrder: number;
-    /** Path to the generated audio file */
-    audioPath: string;
-    /** Approximate duration in seconds */
-    estimatedDuration: number;
-    /** The transcript that was spoken */
-    transcript: string;
-}
-/**
- * Generate audio narration for a list of transcripts.
- */
-export declare function generateNarration(transcripts: {
-    order: number;
-    text: string;
-}[], options: TTSOptions, verbose?: boolean): Promise<GeneratedAudio[]>;
-/**
- * Determine actual audio duration using ffprobe (if available).
- * Falls back to estimation if ffprobe is not installed.
- */
-export declare function getAudioDuration(audioPath: string): Promise<number>;

package/dist/services/video/tts-generator.js

@@ -1,121 +0,0 @@
-/**
- * Text-to-Speech generator for growth video narration.
- * Supports ElevenLabs (primary) and Deepgram (fallback) for professional voiceovers.
- */
-import { mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { logError, logInfo } from '../../utils/logger.js';
-import { fetchWithRetry } from './retry.js';
-// Default voice IDs for different providers
-const DEFAULT_VOICES = {
-    elevenlabs: 'EXAVITQu4vr4xnSDxMaL', // "Sarah" - clear, professional female voice
-    deepgram: 'aura-asteria-en', // Professional English voice
-};
-/**
- * Generate audio narration for a list of transcripts.
- */
-export async function generateNarration(transcripts, options, verbose) {
-    await mkdir(options.outputDir, { recursive: true });
-    const { provider, apiKey } = options;
-    if (!apiKey) {
-        throw new Error(`API key required for ${provider}. Set ${provider === 'elevenlabs' ? 'ELEVENLABS_API_KEY' : 'DEEPGRAM_API_KEY'} environment variable.`);
-    }
-    if (verbose) {
-        logInfo(`Generating ${transcripts.length} audio clips using ${provider}`);
-    }
-    const results = [];
-    for (const { order, text } of transcripts) {
-        try {
-            if (verbose) {
-                logInfo(`Generating audio for scene ${order} (${text.length} chars)`);
-            }
-            let audioBuffer;
-            if (provider === 'elevenlabs') {
-                audioBuffer = await generateElevenLabsAudio(text, options);
-            }
-            else {
-                audioBuffer = await generateDeepgramAudio(text, options);
-            }
-            const audioPath = join(options.outputDir, `narration-${String(order).padStart(3, '0')}.mp3`);
-            await writeFile(audioPath, audioBuffer);
-            // Estimate duration: ~150 words per minute for natural speech
-            const wordCount = text.split(/\s+/).length;
-            const estimatedDuration = (wordCount / 150) * 60;
-            results.push({
-                sceneOrder: order,
-                audioPath,
-                estimatedDuration,
-                transcript: text,
-            });
-            if (verbose) {
-                logInfo(`Scene ${order}: Audio saved (est. ${estimatedDuration.toFixed(1)}s)`);
-            }
-        }
-        catch (error) {
-            logError(`Failed to generate audio for scene ${order}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (results.length === 0) {
-        throw new Error('No audio files were generated successfully');
-    }
-    logInfo(`Generated ${results.length}/${transcripts.length} audio clips`);
-    return results;
-}
-/**
- * Generate audio using ElevenLabs API
- */
-async function generateElevenLabsAudio(text, options) {
-    const voiceId = options.voiceId || DEFAULT_VOICES.elevenlabs;
-    const response = await fetchWithRetry(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'xi-api-key': options.apiKey,
-        },
-        body: JSON.stringify({
-            text,
-            model_id: 'eleven_multilingual_v2',
-            voice_settings: {
-                stability: 0.6,
-                similarity_boost: 0.85,
-                style: 0.3,
-                use_speaker_boost: true,
-            },
-        }),
-    }, { label: 'ElevenLabs TTS' });
-    const arrayBuffer = await response.arrayBuffer();
-    return Buffer.from(arrayBuffer);
-}
-/**
- * Generate audio using Deepgram Aura TTS API
- */
-async function generateDeepgramAudio(text, options) {
-    const voice = options.voiceId || DEFAULT_VOICES.deepgram;
-    const response = await fetchWithRetry(`https://api.deepgram.com/v1/speak?model=${voice}&encoding=mp3`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Token ${options.apiKey}`,
-        },
-        body: JSON.stringify({ text }),
-    }, { label: 'Deepgram TTS' });
-    const arrayBuffer = await response.arrayBuffer();
-    return Buffer.from(arrayBuffer);
-}
-/**
- * Determine actual audio duration using ffprobe (if available).
- * Falls back to estimation if ffprobe is not installed.
- */
-export async function getAudioDuration(audioPath) {
-    try {
-        const { execSync } = await import('child_process');
-        const output = execSync(`ffprobe -v quiet -show_entries format=duration -of csv=p=0 "${audioPath}"`, { encoding: 'utf-8' }).trim();
-        return parseFloat(output);
-    }
-    catch {
-        // Fallback: estimate from file size (~16kbps for compressed speech)
-        const { stat } = await import('fs/promises');
-        const stats = await stat(audioPath);
-        return stats.size / (16 * 1024); // rough estimate
-    }
-}

package/dist/services/video/video-assembler.d.ts

@@ -1,45 +0,0 @@
-/**
- * Video assembler that combines screenshots and audio narration into a video.
- * Uses ffmpeg for professional-quality video output.
- */
-import type { CapturedScene } from './screenshot-generator.js';
-import { type GeneratedAudio } from './tts-generator.js';
-export interface VideoAssemblyOptions {
-    /** Output file path for the final video */
-    outputPath: string;
-    /** Video resolution width */
-    width?: number;
-    /** Video resolution height */
-    height?: number;
-    /** Frames per second */
-    fps?: number;
-    /** Video codec (default: libx264) */
-    codec?: string;
-    /** Output format (default: mp4) */
-    format?: string;
-    /** Video quality preset (default: medium) */
-    preset?: 'ultrafast' | 'fast' | 'medium' | 'slow';
-    /** Add subtle pan/zoom effects (Ken Burns effect) */
-    enableKenBurns?: boolean;
-    /** Crossfade duration between scenes in seconds */
-    crossfadeDuration?: number;
-}
-export interface AssembledVideo {
-    /** Path to the output video file */
-    videoPath: string;
-    /** Total duration in seconds */
-    duration: number;
-    /** File size in bytes */
-    fileSize: number;
-    /** Number of scenes included */
-    sceneCount: number;
-}
-/**
- * Check if ffmpeg is available on the system
- */
-export declare function isFfmpegAvailable(): boolean;
-/**
- * Assemble a video from captured screenshots and audio narration.
- * Each screenshot is displayed for the duration of its corresponding audio.
- */
-export declare function assembleVideo(scenes: CapturedScene[], audioFiles: GeneratedAudio[], options: VideoAssemblyOptions, verbose?: boolean): Promise<AssembledVideo>;