Update server.js

server.js

@@ -17,530 +17,162 @@ const PORT = process.env.PORT || 7860;
 app.use(cors());
 app.use(express.json({ limit: '50mb' }));
 
-// Professional bundle caching with versioning
-let cachedBundle = {
-    location: null,
-    version: 0,
-    timestamp: 0
-};
-const BUNDLE_CACHE_TTL = 10 * 60 * 1000; // 10 minutes
-
 // Health check
 app.get('/', (req, res) => {
-    res.json({ 
-        status: 'ok', 
-        service: 'FacelessFlowAI Video Renderer',
-        version: '2.0.0',
-        uptime: Math.round(process.uptime())
-    });
+    res.json({ status: 'ok', service: 'FacelessFlowAI Video Renderer' });
 });
 
-// Professional bundle management
-async function getBundle() {
-    const now = Date.now();
-    
-    if (cachedBundle.location && (now - cachedBundle.timestamp) < BUNDLE_CACHE_TTL) {
-        console.log('[Bundle] Using cached bundle');
-        return cachedBundle.location;
-    }
-    
-    console.log('[Bundle] Creating production bundle');
-    
-    try {
-        cachedBundle.location = await bundle({
-            entryPoint: join(__dirname, 'remotion', 'index.tsx'),
-            // Professional webpack configuration
-            webpackOverride: (config) => {
-                // Production optimizations
-                config.mode = 'production';
-                config.devtool = false;
-                
-                // Bundle optimizations
-                config.optimization = {
-                    minimize: true,
-                    moduleIds: 'deterministic',
-                    splitChunks: {
-                        chunks: 'async',
-                        minSize: 20000,
-                        maxSize: 70000,
-                    },
-                };
-                
-                // Performance hints
-                config.performance = {
-                    hints: false,
-                    maxEntrypointSize: 512000,
-                    maxAssetSize: 512000,
-                };
-                
-                return config;
-            },
-        });
-        
-        cachedBundle.timestamp = now;
-        cachedBundle.version++;
-        
-        console.log(`[Bundle] Bundle v${cachedBundle.version} ready at ${cachedBundle.location}`);
-        return cachedBundle.location;
-    } catch (error) {
-        console.error('[Bundle] Failed to create bundle:', error);
-        throw error;
-    }
-}
-
-// Professional rendering configuration
-function getRenderConfig() {
-    return {
-        // Video settings
-        codec: 'h264',
-        pixelFormat: 'yuv420p',
-        imageFormat: 'jpeg',
-        jpegQuality: 80,
-        
-        // Performance settings (optimized for L4: 8 vCPU, 30GB RAM)
-        concurrency: 6, // Optimal for 8-core system
-        disallowParallelEncoding: false,
-        // REMOVED: numberOfGifLoops: 0, // Only for GIF codec
-        
-        // Audio settings
-        audioBitrate: '192k',
-        videoBitrate: '8M',
-        muted: false,
-        
-        // Chromium settings (professional defaults)
-        chromiumOptions: {
-            executablePath: '/usr/bin/google-chrome-stable',
-            enableMultiProcessRendering: true,
-            ignoreDefaultArgs: ['--disable-gpu'],
-            args: [
-                '--no-sandbox',
-                '--disable-dev-shm-usage',
-                '--disable-setuid-sandbox',
-                '--disable-accelerated-2d-canvas',
-                '--disable-gpu',
-                '--hide-scrollbars',
-                '--disable-notifications',
-                '--disable-background-timer-throttling',
-                '--disable-backgrounding-occluded-windows',
-                '--disable-renderer-backgrounding',
-                '--disable-features=ScriptStreaming',
-                '--disable-features=VizDisplayCompositor',
-            ],
-        },
-        
-        // FFmpeg settings (professional defaults)
-        ffmpegOverride: undefined, // Let Remotion handle FFmpeg
-    };
-}
-
-// Professional error handling
-class RenderError extends Error {
-    constructor(message, code, details) {
-        super(message);
-        this.name = 'RenderError';
-        this.code = code;
-        this.details = details;
-    }
-}
-
-// Main render function (professional pattern)
-async function renderVideo(params) {
-    const { compositionId, serveUrl, inputProps, onProgress } = params;
-    
-    console.log('[Render] Selecting composition...');
-    const composition = await selectComposition({
-        serveUrl,
-        id: compositionId,
-        inputProps,
-        chromiumOptions: getRenderConfig().chromiumOptions,
-    });
-    
-    console.log(`[Render] Composition: ${composition.durationInFrames} frames @ ${composition.fps}fps`);
-    
-    const tempDir = join(tmpdir(), `render-${randomUUID()}`);
-    await mkdir(tempDir, { recursive: true });
-    const outputPath = join(tempDir, 'output.mp4');
-    
-    const renderConfig = getRenderConfig();
-    
-    console.log('[Render] Starting render...');
-    
-    const startTime = Date.now();
-    let lastProgress = 0;
-    
-    try {
-        await renderMedia({
-            composition,
-            serveUrl,
-            outputLocation: outputPath,
-            inputProps,
-            onProgress: ({ progress }) => {
-                const percent = Math.round(progress * 100);
-                if (percent !== lastProgress && percent % 5 === 0) {
-                    console.log(`[Progress] ${percent}%`);
-                    lastProgress = percent;
-                    if (onProgress) onProgress(progress);
-                }
-            },
-            ...renderConfig,
-        });
-        
-        const renderTime = Date.now() - startTime;
-        const fps = Math.round(composition.durationInFrames / (renderTime / 1000));
-        
-        console.log(`[Render] Completed in ${Math.round(renderTime / 1000)}s (${fps} FPS)`);
-        
-        const videoBuffer = await readFile(outputPath);
-        const fileSizeMB = Math.round(videoBuffer.length / (1024 * 1024));
-        
-        console.log(`[Render] Output: ${fileSizeMB}MB`);
-        
-        // Cleanup temp directory
-        await rm(tempDir, { recursive: true, force: true });
-        
-        return {
-            buffer: videoBuffer,
-            duration: renderTime,
-            fps: fps,
-            fileSizeMB: fileSizeMB,
-            composition: composition,
-        };
-        
-    } catch (error) {
-        // Cleanup on error
-        try {
-            await rm(tempDir, { recursive: true, force: true });
-        } catch (cleanupError) {
-            console.warn('[Cleanup] Failed to cleanup temp dir:', cleanupError);
-        }
-        
-        throw new RenderError(
-            `Render failed: ${error.message}`,
-            'RENDER_FAILED',
-            { originalError: error.message }
-        );
-    }
-}
-
-// Render endpoint (professional API design)
+// Render endpoint
 app.post('/render', async (req, res) => {
     const { projectId, scenes, settings } = req.body;
-    
-    // Input validation
+
     if (!projectId || !scenes || !settings) {
-        return res.status(400).json({
-            error: 'VALIDATION_ERROR',
-            message: 'Missing required fields: projectId, scenes, or settings',
-            required: ['projectId', 'scenes', 'settings']
-        });
+        return res.status(400).json({ error: 'Missing projectId, scenes, or settings' });
     }
-    
-    // Initialize Supabase
+
+    // Initialize Supabase Admin Client
     const SUPABASE_URL = process.env.SUPABASE_URL;
     const SUPABASE_SERVICE_ROLE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY;
-    
+
     if (!SUPABASE_URL || !SUPABASE_SERVICE_ROLE_KEY) {
-        return res.status(500).json({
-            error: 'CONFIGURATION_ERROR',
-            message: 'Server configuration error'
-        });
+        console.error('[Config] Missing Supabase credentials');
+        return res.status(500).json({ error: 'Renderer configuration error' });
     }
-    
+
     const { createClient } = await import('@supabase/supabase-js');
     const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY);
-    
-    // Accept request immediately (async processing)
-    res.json({
-        success: true,
-        message: 'Render job accepted',
-        jobId: projectId,
-        estimatedTime: 'Processing...'
-    });
-    
-    // Start async processing
+
+    // 1. Respond immediately
+    res.json({ success: true, message: 'Rendering started in background' });
+
+    // 2. Start Background Process
     (async () => {
         try {
-            console.log(`[Job ${projectId}] Starting render job`);
-            
-            // Update status to processing
-            await supabase
-                .from('projects')
-                .update({
-                    status: 'processing',
-                    started_at: new Date().toISOString()
-                })
-                .eq('id', projectId);
-            
-            // Get bundle
-            const bundleLocation = await getBundle();
-            
-            // Render video
-            const result = await renderVideo({
-                compositionId: 'Main',
+            console.log(`[Render] Starting background render for project ${projectId}`);
+
+            const bundleLocation = await bundle({
+                entryPoint: join(__dirname, 'remotion', 'index.tsx'),
+                webpackOverride: (config) => config,
+            });
+
+            const composition = await selectComposition({
+                serveUrl: bundleLocation,
+                id: 'Main',
+                inputProps: { scenes, settings },
+                chromiumOptions: { executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable' },
+            });
+
+            const tempDir = join(tmpdir(), `remotion-${randomUUID()}`);
+            await mkdir(tempDir, { recursive: true });
+            const outputPath = join(tempDir, 'output.mp4');
+
+            const os = await import('os');
+            const cpuCount = os.cpus().length;
+            console.log(`[Render] Detected ${cpuCount} CPUs. Using all cores for rendering.`);
+
+            // Tuning for L4 (8 vCPU / 30GB RAM / 24GB VRAM)
+            // 8 vCPUs means going above 8 concurrency won't help (context switching).
+            // 30GB RAM / 8 = ~3.7GB per instance. Chrome can exceed this.
+            // Safe sweet spot is likely 6.
+            // Enabling Chrome GPU (gl: 'angle') moves load to VRAM, helping stability.
+            const safeConcurrency = Math.min(cpuCount, 6);
+            console.log(`[Render] Requesting concurrency: ${safeConcurrency} (Host has ${cpuCount})`);
+
+            let lastLog = 0;
+
+            await renderMedia({
+                composition,
                 serveUrl: bundleLocation,
+                codec: 'h264',
+                pixelFormat: 'yuv420p',
+                outputLocation: outputPath,
+                imageFormat: 'jpeg',
+                jpegQuality: 80,
                 inputProps: { scenes, settings },
-                onProgress: (progress) => {
-                    // Optional: Send progress updates via WebSocket or store in DB
-                    console.log(`[Job ${projectId}] Progress: ${Math.round(progress * 100)}%`);
+                chromiumOptions: {
+                    executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
+                    enableMultiProcessRendering: true,
+                    // Enable GPU acceleration for Chrome compositing (HUGE for L40)
+                    gl: 'angle',
+                    ignoreDefaultArgs: ['--disable-gpu'],
+                    args: ['--use-gl=angle', '--use-angle=gl-egl', '--no-sandbox']
+                },
+                concurrency: safeConcurrency,
+                disallowParallelEncoding: false,
+                onProgress: ({ progress }) => {
+                    const percent = Math.round(progress * 100);
+                    // Log every 2%
+                    if (percent - lastLog >= 2 || percent === 100) {
+                        console.log(`[Render] Progress: ${percent}%`);
+                        lastLog = percent;
+                    }
+                },
+                ffmpegOverride: ({ args }) => {
+                    // NVENC Preset p1 = Fastest (lowest latency/quality trade-off for speed)
+                    return [...args, '-c:v', 'h264_nvenc', '-preset', 'p1'];
                 }
             });
-            
+
+            console.log(`[Render] Render complete. Uploading to Supabase...`);
+
+            const videoBuffer = await readFile(outputPath);
+
             // Upload to Supabase Storage
-            const fileName = `${projectId}/${Date.now()}-${randomUUID().slice(0, 8)}.mp4`;
-            const contentType = 'video/mp4';
-            
-            console.log(`[Job ${projectId}] Uploading to storage...`);
-            
-            const { error: uploadError } = await supabase.storage
-                .from('projects')
-                .upload(fileName, result.buffer, {
-                    contentType,
-                    cacheControl: '3600',
-                    upsert: false
+            const fileName = `${projectId}/video-${Date.now()}.mp4`;
+            const { data: uploadData, error: uploadError } = await supabase
+                .storage
+                .from('projects') // Assuming 'projects' bucket exists
+                .upload(fileName, videoBuffer, {
+                    contentType: 'video/mp4',
+                    upsert: true
                 });
-            
-            if (uploadError) throw uploadError;
-            
-            // Get public URL
-            const { data: { publicUrl } } = supabase.storage
+
+            if (uploadError) throw new Error(`Upload failed: ${uploadError.message}`);
+
+            // Get Public URL
+            const { data: { publicUrl } } = supabase
+                .storage
                 .from('projects')
                 .getPublicUrl(fileName);
-            
-            // Update project with success
-            await supabase
+
+            console.log(`[Render] Uploaded to ${publicUrl}`);
+
+            // Update Project in DB
+            const { error: dbError } = await supabase
                 .from('projects')
                 .update({
-                    status: 'completed',
-                    video_url: publicUrl,
-                    rendered_at: new Date().toISOString(),
-                    render_metadata: {
-                        duration_ms: result.duration,
-                        file_size_mb: result.fileSizeMB,
-                        fps: result.fps,
-                        total_frames: result.composition.durationInFrames,
-                        resolution: `${result.composition.width}x${result.composition.height}`,
-                        timestamp: new Date().toISOString()
-                    }
+                    status: 'done',
+                    video_url: publicUrl
                 })
                 .eq('id', projectId);
-            
-            console.log(`[Job ${projectId}] Completed successfully`);
-            
+
+            if (dbError) throw new Error(`DB Update failed: ${dbError.message}`);
+
+            console.log(`[Render] Project ${projectId} updated successfully`);
+
+            // Cleanup
+            await rm(tempDir, { recursive: true, force: true });
+
         } catch (error) {
-            console.error(`[Job ${projectId}] Failed:`, error.message);
-            
-            // Update with error
-            try {
-                await supabase
-                    .from('projects')
-                    .update({
-                        status: 'failed',
-                        error_message: error.message,
-                        error_details: error.details || {},
-                        failed_at: new Date().toISOString()
-                    })
-                    .eq('id', projectId);
-            } catch (dbError) {
-                console.error(`[Job ${projectId}] Failed to update error status:`, dbError.message);
-            }
+            console.error(`[Render] Background Error for ${projectId}:`, error);
+            // Update project status to 'error'
+            await supabase
+                .from('projects')
+                .update({
+                    status: 'error',
+                })
+                .eq('id', projectId);
         }
     })();
 });
 
-// Status endpoint with detailed info
-app.get('/status', async (req, res) => {
-    const os = await import('os');
-    
-    const status = {
-        service: 'FacelessFlowAI Renderer',
-        version: '2.0.0',
-        status: 'operational',
-        uptime: Math.round(process.uptime()),
-        
-        // System info
-        system: {
-            cpu_cores: os.cpus().length,
-            total_memory_gb: Math.round(os.totalmem() / (1024 ** 3)),
-            free_memory_gb: Math.round(os.freemem() / (1024 ** 3)),
-            platform: os.platform(),
-            arch: os.arch()
-        },
-        
-        // Service info
-        service_info: {
-            bundle_cached: cachedBundle.location !== null,
-            bundle_version: cachedBundle.version,
-            cache_age_minutes: cachedBundle.timestamp ? 
-                Math.round((Date.now() - cachedBundle.timestamp) / 60000) : null
-        },
-        
-        // Configuration
-        config: {
-            max_concurrency: 6,
-            codec: 'h264',
-            default_resolution: '1920x1080',
-            default_fps: 30
-        },
-        
-        timestamp: new Date().toISOString()
-    };
-    
-    res.json(status);
-});
-
-// Metrics endpoint (for monitoring)
-app.get('/metrics', async (req, res) => {
-    const os = await import('os');
-    const { execSync } = await import('child_process');
-    
-    try {
-        // System metrics
-        const loadAvg = os.loadavg();
-        const memoryUsage = process.memoryUsage();
-        
-        // GPU metrics if available
-        let gpuInfo = null;
-        try {
-            const gpuOutput = execSync('nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv,noheader,nounits 2>/dev/null || echo ""', { encoding: 'utf8' });
-            if (gpuOutput.trim()) {
-                const [gpuUtil, memUsed, memTotal] = gpuOutput.trim().split(', ').map(Number);
-                gpuInfo = {
-                    utilization_percent: gpuUtil,
-                    memory_used_mb: memUsed,
-                    memory_total_mb: memTotal,
-                    memory_usage_percent: Math.round((memUsed / memTotal) * 100)
-                };
-            }
-        } catch {
-            // GPU not available or nvidia-smi not installed
-        }
-        
-        const metrics = {
-            timestamp: new Date().toISOString(),
-            system: {
-                load_avg: loadAvg,
-                memory: {
-                    rss_mb: Math.round(memoryUsage.rss / 1024 / 1024),
-                    heap_total_mb: Math.round(memoryUsage.heapTotal / 1024 / 1024),
-                    heap_used_mb: Math.round(memoryUsage.heapUsed / 1024 / 1024),
-                    external_mb: Math.round(memoryUsage.external / 1024 / 1024)
-                },
-                uptime: process.uptime()
-            },
-            gpu: gpuInfo,
-            service: {
-                bundle_cache_hit: cachedBundle.location !== null,
-                active_requests: 0 // You could track this
-            }
-        };
-        
-        res.json(metrics);
-    } catch (error) {
-        res.status(500).json({ error: error.message });
-    }
-});
+app.listen(PORT, () => {
+    console.log(`🎬 FacelessFlowAI Renderer running on port ${PORT}`);
 
-// System check endpoint
-app.get('/health', async (req, res) => {
-    const checks = [];
-    
-    // Check 1: System memory
-    try {
-        const os = await import('os');
-        const freeMemoryGB = Math.round(os.freemem() / (1024 ** 3));
-        checks.push({
-            name: 'system_memory',
-            status: freeMemoryGB > 2 ? 'healthy' : 'warning',
-            message: `${freeMemoryGB}GB free memory`,
-            value: freeMemoryGB
-        });
-    } catch (error) {
-        checks.push({
-            name: 'system_memory',
-            status: 'error',
-            message: error.message
-        });
-    }
-    
-    // Check 2: Chrome availability
-    try {
-        const { execSync } = await import('child_process');
-        execSync('/usr/bin/google-chrome-stable --version', { stdio: 'pipe' });
-        checks.push({
-            name: 'chrome',
-            status: 'healthy',
-            message: 'Chrome is available'
-        });
-    } catch (error) {
-        checks.push({
-            name: 'chrome',
-            status: 'warning',
-            message: 'Chrome not found, will use headless shell'
-        });
-    }
-    
-    // Check 3: FFmpeg
-    try {
-        const { execSync } = await import('child_process');
-        execSync('ffmpeg -version', { stdio: 'pipe' });
-        checks.push({
-            name: 'ffmpeg',
-            status: 'healthy',
-            message: 'FFmpeg is available'
-        });
-    } catch (error) {
-        checks.push({
-            name: 'ffmpeg',
-            status: 'error',
-            message: 'FFmpeg not found'
-        });
-    }
-    
-    // Check 4: Bundle status
-    checks.push({
-        name: 'bundle',
-        status: cachedBundle.location ? 'healthy' : 'warming',
-        message: cachedBundle.location ? 'Bundle cached' : 'Bundle warming up',
-        version: cachedBundle.version
-    });
-    
-    const allHealthy = checks.every(c => c.status === 'healthy' || c.status === 'warning');
-    const anyError = checks.some(c => c.status === 'error');
-    
-    res.json({
-        status: anyError ? 'degraded' : (allHealthy ? 'healthy' : 'warning'),
-        checks: checks,
-        timestamp: new Date().toISOString()
-    });
+    // Debug: Check for Secrets on Startup
+    console.log('--- Environment Check ---');
+    console.log('SUPABASE_URL exists:', !!process.env.SUPABASE_URL);
+    console.log('SUPABASE_SERVICE_ROLE_KEY exists:', !!process.env.SUPABASE_SERVICE_ROLE_KEY);
+    console.log('Available Keys (starts with SUPA):', Object.keys(process.env).filter(k => k.startsWith('SUPA')));
+    console.log('-------------------------');
 });
-
-// Start server
-app.listen(PORT, () => {
-    console.log(`
-    🎬 FacelessFlowAI Professional Renderer
-    ======================================
-    Port: ${PORT}
-    Mode: Production
-    Hardware: L4 GPU (8 vCPU, 30GB RAM)
-    
-    Endpoints:
-    - GET  /           Service status
-    - GET  /health     System health check
-    - GET  /status     Detailed service info
-    - GET  /metrics    System metrics
-    - POST /render     Render video
-    
-    Initializing...
-    `);
-    
-    // Warm up the system
-    setTimeout(async () => {
-        try {
-            console.log('[Init] Warming up renderer...');
-            await getBundle();
-            console.log('[Init] Renderer ready');
-        } catch (error) {
-            console.error('[Init] Warmup failed:', error.message);
-        }
-    }, 2000);
-});