edsger 0.77.0 → 0.79.0

package/dist/services/video/index.d.ts

@@ -1,66 +0,0 @@
-/**
- * Growth video generation pipeline.
- * Orchestrates screenshot capture, TTS narration, video assembly, and upload.
- */
-import { type VideoScene } from './screenshot-generator.js';
-export interface VideoGenerationPlan {
-    /** Whether this content suggestion should have a video */
-    shouldGenerateVideo: boolean;
-    /** Reason for the video decision */
-    videoReason: string;
-    /** Scenes for the video (if shouldGenerateVideo is true) */
-    scenes: VideoScene[];
-    /** HTML templates for static rendering (when no live app available) */
-    htmlTemplates?: string[];
-}
-export interface GrowthVideoResult {
-    /** Whether video was successfully generated */
-    success: boolean;
-    /** Video URL (from Supabase Storage) */
-    videoUrl?: string;
-    /** Local backup path */
-    localPath?: string;
-    /** Video duration in seconds */
-    duration?: number;
-    /** Number of scenes */
-    sceneCount?: number;
-    /** File size in bytes */
-    fileSize?: number;
-    /** Error message if generation failed */
-    error?: string;
-}
-export interface VideoGenerationOptions {
-    productId: string;
-    analysisId: string;
-    /** TTS provider preference */
-    ttsProvider?: 'elevenlabs' | 'deepgram';
-    /** ElevenLabs API key (or from env) */
-    elevenlabsApiKey?: string;
-    /** Deepgram API key (or from env) */
-    deepgramApiKey?: string;
-    /** Voice ID for TTS */
-    voiceId?: string;
-    /** Base URL if a live app is running */
-    baseUrl?: string;
-    verbose?: boolean;
-}
-/**
- * Check system dependencies for video generation.
- * Auto-installs Playwright if missing. Returns a list of still-missing dependencies.
- */
-export declare function checkVideoDependencies(): Promise<string[]>;
-/**
- * Generate a growth video from a video generation plan.
- *
- * Pipeline:
- * 1. Capture screenshots (from live app or static HTML)
- * 2. Generate TTS narration for each scene's transcript
- * 3. Assemble video from screenshots + audio
- * 4. Upload to Supabase Storage + save local backup
- * 5. Return video URL and metadata
- */
-export declare function generateGrowthVideo(plan: VideoGenerationPlan, options: VideoGenerationOptions): Promise<GrowthVideoResult>;
-export type { CapturedScene, VideoScene } from './screenshot-generator.js';
-export type { GeneratedAudio } from './tts-generator.js';
-export type { AssembledVideo } from './video-assembler.js';
-export type { VideoUploadResult } from './video-uploader.js';

package/dist/services/video/index.js

@@ -1,238 +0,0 @@
-/**
- * Growth video generation pipeline.
- * Orchestrates screenshot capture, TTS narration, video assembly, and upload.
- */
-import { mkdir, rm } from 'fs/promises';
-import { join } from 'path';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { ensureFFmpeg, ensurePlaywright } from '../../utils/validation.js';
-import { captureStaticScreenshots, getVideoTempDir, isPlaywrightAvailable, } from './screenshot-generator.js';
-import { generateNarration } from './tts-generator.js';
-import { assembleVideo, isFfmpegAvailable } from './video-assembler.js';
-import { saveVideoMetadata, uploadGrowthVideo } from './video-uploader.js';
-/**
- * Check system dependencies for video generation.
- * Auto-installs Playwright if missing. Returns a list of still-missing dependencies.
- */
-export async function checkVideoDependencies() {
-    const missing = [];
-    try {
-        ensureFFmpeg(isFfmpegAvailable);
-    }
-    catch {
-        missing.push('ffmpeg (auto-install failed — install manually: brew install ffmpeg / apt install ffmpeg)');
-    }
-    try {
-        await ensurePlaywright(isPlaywrightAvailable);
-    }
-    catch {
-        missing.push('playwright (auto-install failed — run: npm install playwright && npx playwright install chromium)');
-    }
-    return missing;
-}
-/**
- * Resolve TTS configuration from options and environment variables.
- */
-function resolveTTSConfig(options) {
-    // Try ElevenLabs first
-    const elevenlabsKey = options.elevenlabsApiKey || process.env.ELEVENLABS_API_KEY;
-    if (elevenlabsKey) {
-        return {
-            provider: 'elevenlabs',
-            apiKey: elevenlabsKey,
-            voiceId: options.voiceId,
-            outputDir: '', // will be set later
-        };
-    }
-    // Try Deepgram as fallback
-    const deepgramKey = options.deepgramApiKey || process.env.DEEPGRAM_API_KEY;
-    if (deepgramKey) {
-        return {
-            provider: 'deepgram',
-            apiKey: deepgramKey,
-            voiceId: options.voiceId,
-            outputDir: '', // will be set later
-        };
-    }
-    return null;
-}
-/**
- * Generate a growth video from a video generation plan.
- *
- * Pipeline:
- * 1. Capture screenshots (from live app or static HTML)
- * 2. Generate TTS narration for each scene's transcript
- * 3. Assemble video from screenshots + audio
- * 4. Upload to Supabase Storage + save local backup
- * 5. Return video URL and metadata
- */
-export async function generateGrowthVideo(plan, options) {
-    const { productId, analysisId, verbose } = options;
-    if (!plan.shouldGenerateVideo || plan.scenes.length === 0) {
-        return {
-            success: false,
-            error: 'No video generation requested',
-        };
-    }
-    logInfo(`Starting video generation for product ${productId}`);
-    // Check dependencies
-    const missing = await checkVideoDependencies();
-    if (missing.length > 0) {
-        const errorMsg = `Missing dependencies:\n${missing.map((m) => `  - ${m}`).join('\n')}`;
-        logError(errorMsg);
-        return { success: false, error: errorMsg };
-    }
-    // Check TTS configuration
-    const ttsConfig = resolveTTSConfig(options);
-    if (!ttsConfig) {
-        const errorMsg = 'No TTS API key configured. Set ELEVENLABS_API_KEY or DEEPGRAM_API_KEY environment variable.';
-        logError(errorMsg);
-        return { success: false, error: errorMsg };
-    }
-    // Set up working directories
-    const workDir = getVideoTempDir(productId);
-    const screenshotDir = join(workDir, 'screenshots');
-    const audioDir = join(workDir, 'audio');
-    const outputDir = join(workDir, 'output');
-    await mkdir(outputDir, { recursive: true });
-    try {
-        // Step 1: Capture screenshots
-        logInfo('Step 1/4: Capturing screenshots...');
-        let capturedScenes;
-        if (plan.htmlTemplates && plan.htmlTemplates.length > 0) {
-            // Validate and sanitize AI-generated HTML templates
-            const validatedTemplates = validateHtmlTemplates(plan.htmlTemplates, plan.scenes);
-            capturedScenes = await captureStaticScreenshots(plan.scenes, screenshotDir, validatedTemplates, verbose);
-        }
-        else if (options.baseUrl) {
-            // Use live application
-            const { captureScreenshots } = await import('./screenshot-generator.js');
-            capturedScenes = await captureScreenshots(plan.scenes, {
-                baseUrl: options.baseUrl,
-                outputDir: screenshotDir,
-            }, verbose);
-        }
-        else {
-            // Fallback: use static HTML templates (must be provided by AI)
-            return {
-                success: false,
-                error: 'No base URL or HTML templates provided for screenshots',
-            };
-        }
-        // Step 2: Generate TTS narration
-        logInfo('Step 2/4: Generating narration...');
-        ttsConfig.outputDir = audioDir;
-        const transcripts = capturedScenes.map((scene) => ({
-            order: scene.order,
-            text: scene.transcript,
-        }));
-        const audioFiles = await generateNarration(transcripts, ttsConfig, verbose);
-        // Step 3: Assemble video
-        logInfo('Step 3/4: Assembling video...');
-        const outputPath = join(outputDir, `growth-${productId}.mp4`);
-        const assembledVideo = await assembleVideo(capturedScenes, audioFiles, { outputPath }, verbose);
-        // Step 4: Upload and save
-        logInfo('Step 4/4: Uploading video...');
-        const uploadResult = await uploadGrowthVideo(assembledVideo.videoPath, productId, analysisId, verbose);
-        // Save metadata only if upload succeeded (has a public URL)
-        if (uploadResult.publicUrl) {
-            await saveVideoMetadata(analysisId, {
-                video_url: uploadResult.publicUrl,
-                video_storage_path: uploadResult.storagePath,
-                video_local_path: uploadResult.localPath,
-                video_duration: assembledVideo.duration,
-                video_file_size: assembledVideo.fileSize,
-                video_scene_count: assembledVideo.sceneCount,
-            }, verbose);
-        }
-        logSuccess('Video generation completed successfully!');
-        return {
-            success: true,
-            videoUrl: uploadResult.publicUrl,
-            localPath: uploadResult.localPath,
-            duration: assembledVideo.duration,
-            sceneCount: assembledVideo.sceneCount,
-            fileSize: assembledVideo.fileSize,
-        };
-    }
-    catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        logError(`Video generation failed: ${errorMsg}`);
-        return { success: false, error: errorMsg };
-    }
-    finally {
-        // Clean up temp working directory (screenshots, audio, intermediate files)
-        try {
-            await rm(workDir, { recursive: true, force: true });
-            if (verbose) {
-                logInfo(`Cleaned up temp directory: ${workDir}`);
-            }
-        }
-        catch {
-            logWarning(`Could not clean up temp directory: ${workDir}`);
-        }
-    }
-}
-/**
- * Validate AI-generated HTML templates and return sanitized versions.
- * Replaces invalid or empty templates with a styled fallback error page.
- */
-function validateHtmlTemplates(templates, scenes) {
-    return templates.map((html, i) => {
-        const scene = scenes[i];
-        const sceneLabel = scene
-            ? `Scene ${scene.order}: ${scene.description}`
-            : `Scene ${i + 1}`;
-        // Check minimum viable HTML
-        if (!html || html.trim().length < 50) {
-            logWarning(`Invalid HTML template for ${sceneLabel} (too short), using fallback`);
-            return generateFallbackHtml(sceneLabel);
-        }
-        // Check for basic HTML structure
-        const lower = html.toLowerCase();
-        if (!lower.includes('<html') &&
-            !lower.includes('<body') &&
-            !lower.includes('<div')) {
-            logWarning(`Invalid HTML template for ${sceneLabel} (no HTML structure), using fallback`);
-            return generateFallbackHtml(sceneLabel);
-        }
-        // Wrap partial HTML (missing <html>/<body>) in a full document
-        if (!lower.includes('<html')) {
-            const wrapped = `<!DOCTYPE html><html><head><meta charset="utf-8"><style>body{margin:0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;}</style></head><body>${html}</body></html>`;
-            return wrapped;
-        }
-        return html;
-    });
-}
-/**
- * Escape a string for safe embedding in HTML content.
- */
-function escapeHtml(str) {
-    return str
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#39;');
-}
-/**
- * Generate a styled fallback HTML page when a template is invalid.
- */
-function generateFallbackHtml(sceneLabel) {
-    const safeLabel = escapeHtml(sceneLabel);
-    return `<!DOCTYPE html>
-<html><head><meta charset="utf-8"><style>
-  body { margin: 0; display: flex; align-items: center; justify-content: center;
-    min-height: 100vh; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; color: #fff; }
-  .card { background: rgba(255,255,255,0.15); backdrop-filter: blur(10px);
-    border-radius: 16px; padding: 48px; text-align: center; max-width: 500px; }
-  h2 { font-size: 24px; margin: 0 0 12px; }
-  p { font-size: 16px; opacity: 0.85; margin: 0; }
-</style></head><body>
-  <div class="card">
-    <h2>${safeLabel}</h2>
-    <p>Content preview</p>
-  </div>
-</body></html>`;
-}

package/dist/services/video/retry.d.ts

@@ -1,20 +0,0 @@
-/**
- * Shared retry utility for network requests in the video pipeline.
- * Uses exponential backoff with jitter for resilient API calls.
- */
-export interface RetryOptions {
-    /** Max number of retry attempts (default: 3) */
-    maxRetries?: number;
-    /** Base delay in ms for exponential backoff (default: 1000) */
-    baseDelayMs?: number;
-    /** HTTP status codes that should trigger a retry (default: 429, 500, 502, 503, 504) */
-    retryableStatuses?: number[];
-    /** Label for log messages */
-    label?: string;
-}
-/**
- * Fetch with automatic retry on transient failures.
- * Retries on network errors and retryable HTTP status codes
- * using exponential backoff with jitter.
- */
-export declare function fetchWithRetry(url: string, init: RequestInit, options?: RetryOptions): Promise<Response>;

package/dist/services/video/retry.js

@@ -1,76 +0,0 @@
-/**
- * Shared retry utility for network requests in the video pipeline.
- * Uses exponential backoff with jitter for resilient API calls.
- */
-import { logWarning } from '../../utils/logger.js';
-const DEFAULT_RETRYABLE_STATUSES = [429, 500, 502, 503, 504];
-/**
- * Fetch with automatic retry on transient failures.
- * Retries on network errors and retryable HTTP status codes
- * using exponential backoff with jitter.
- */
-export async function fetchWithRetry(url, init, options = {}) {
-    const { maxRetries = 3, baseDelayMs = 1000, retryableStatuses = DEFAULT_RETRYABLE_STATUSES, label = 'fetch', } = options;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            const response = await fetch(url, init);
-            if (response.ok) {
-                return response;
-            }
-            // Check if the status is retryable
-            if (retryableStatuses.includes(response.status) && attempt < maxRetries) {
-                const delay = calculateBackoff(attempt, baseDelayMs);
-                logWarning(`${label}: HTTP ${response.status}, retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt + 1}/${maxRetries})`);
-                await sleep(delay);
-                continue;
-            }
-            // Non-retryable error status — throw immediately
-            const errorText = await response.text();
-            throw new Error(`${label} failed (${response.status}): ${errorText}`);
-        }
-        catch (error) {
-            // Network errors (ECONNRESET, ETIMEDOUT, etc.) are retryable
-            if (error instanceof TypeError ||
-                (error instanceof Error && isNetworkError(error))) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (attempt < maxRetries) {
-                    const delay = calculateBackoff(attempt, baseDelayMs);
-                    logWarning(`${label}: Network error, retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt + 1}/${maxRetries}): ${lastError.message}`);
-                    await sleep(delay);
-                    continue;
-                }
-            }
-            // Non-retryable error or max retries exhausted
-            throw error;
-        }
-    }
-    throw lastError || new Error(`${label}: All ${maxRetries} retries exhausted`);
-}
-/**
- * Calculate exponential backoff delay with jitter.
- */
-function calculateBackoff(attempt, baseDelayMs) {
-    const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
-    // Add random jitter (0-50% of delay) to avoid thundering herd
-    const jitter = exponentialDelay * Math.random() * 0.5;
-    return exponentialDelay + jitter;
-}
-/**
- * Check if an error is a transient network error worth retrying.
- */
-function isNetworkError(error) {
-    const message = error.message.toLowerCase();
-    return (message.includes('econnreset') ||
-        message.includes('etimedout') ||
-        message.includes('econnrefused') ||
-        message.includes('epipe') ||
-        message.includes('network') ||
-        message.includes('socket') ||
-        message.includes('abort'));
-}
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}

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

@@ -1,69 +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 { type DeviceFrameType } from './device-frames.js';
-export type { DeviceFrameType } from './device-frames.js';
-export interface VideoScene {
-    /** Scene number for ordering */
-    order: number;
-    /** Page URL path to navigate to (e.g., "/dashboard", "/settings") */
-    pagePath: string;
-    /** Description of what the screenshot should show */
-    description: string;
-    /** Transcript/narration text for this scene */
-    transcript: string;
-    /** Duration in seconds this scene should be shown */
-    duration: number;
-    /** Optional: JavaScript to execute before screenshot (e.g., to inject mock data) */
-    setupScript?: string;
-    /** Optional: CSS selector to wait for before capturing */
-    waitForSelector?: string;
-    /** Optional: viewport width override */
-    viewportWidth?: number;
-    /** Optional: viewport height override */
-    viewportHeight?: number;
-    /** Device frame to wrap screenshot in (macbook, iphone, browser, none). Default: auto-detect */
-    deviceFrame?: DeviceFrameType;
-    /** Background color/gradient behind the device frame */
-    frameBackground?: string;
-    /** URL to show in browser address bar (browser frame only) */
-    frameBrowserUrl?: string;
-}
-export interface CapturedScene extends VideoScene {
-    /** Local file path to the captured screenshot */
-    screenshotPath: string;
-}
-export interface ScreenshotOptions {
-    /** Base URL of the running application */
-    baseUrl: string;
-    /** Directory to save screenshots */
-    outputDir: string;
-    /** Default viewport width */
-    viewportWidth?: number;
-    /** Default viewport height */
-    viewportHeight?: number;
-    /** Whether to capture full page or just viewport */
-    fullPage?: boolean;
-}
-/**
- * Check if Playwright is available
- */
-export declare function isPlaywrightAvailable(): Promise<boolean>;
-/**
- * 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 declare function getVideoTempDir(productId: string): string;
-/**
- * Capture screenshots for all scenes using Playwright.
- * Requires Playwright to be installed: npm install playwright
- */
-export declare function captureScreenshots(scenes: VideoScene[], options: ScreenshotOptions, verbose?: boolean): Promise<CapturedScene[]>;
-/**
- * Generate screenshots using static HTML rendering (fallback when no running app).
- * Creates screenshots from pre-built HTML templates with mock data.
- */
-export declare function captureStaticScreenshots(scenes: VideoScene[], outputDir: string, htmlTemplates: string[], verbose?: boolean): Promise<CapturedScene[]>;