Update server.js

server.js

@@ -2,7 +2,7 @@ import express from 'express';
 import cors from 'cors';
 import { bundle } from '@remotion/bundler';
 import { renderMedia, selectComposition } from '@remotion/renderer';
-import { readFile, mkdir, rm } from 'fs/promises';
+import { readFile, mkdir, rm, existsSync } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join, dirname } from 'path';
 import { randomUUID } from 'crypto';
@@ -26,12 +26,11 @@ const BUNDLE_CACHE_TTL = 5 * 60 * 1000;
 app.get('/', (req, res) => {
     res.json({ 
         status: 'ok', 
-        service: 'FacelessFlowAI Video Renderer',
-        gpu_available: process.env.COMPUTE_TYPE === 'gpu'
+        service: 'FacelessFlowAI Video Renderer'
     });
 });
 
-// Get bundle with caching
+// Get bundle with caching - IMPROVED VERSION
 async function getCachedBundle() {
     const now = Date.now();
     
@@ -42,68 +41,64 @@ async function getCachedBundle() {
     
     console.log('[Performance] Creating new bundle');
     
-    cachedBundle = await bundle({
-        entryPoint: join(__dirname, 'remotion', 'index.tsx'),
-        webpackOverride: (config) => {
-            config.output = {
-                ...config.output,
-                filename: '[name].js',
-                chunkFilename: '[name].chunk.js',
-            };
-            
-            config.optimization = {
-                ...config.optimization,
-                splitChunks: false,
-                runtimeChunk: false,
-            };
-            
-            config.mode = 'production';
-            config.devtool = false;
-            
-            return config;
-        },
-    });
-    
-    lastBundleTime = now;
-    return cachedBundle;
-}
-
-// Check if GPU is available
-function isGpuAvailable() {
-    return process.env.COMPUTE_TYPE === 'gpu' || 
-           process.env.CUDA_VISIBLE_DEVICES !== undefined;
-}
-
-// Get optimized chromium options
-function getChromiumOptions() {
-    const baseOptions = {
-        executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
-        enableMultiProcessRendering: true,
-        ignoreDefaultArgs: ['--disable-gpu'],
-        args: ['--no-sandbox', '--disable-dev-shm-usage']
-    };
-    
-    return baseOptions;
-}
-
-// Get FFmpeg override
-function getFFmpegOverride() {
-    return ({ args }) => {
-        return [
-            ...args,
-            '-c:v', 'libx264',
-            '-preset', 'fast',
-            '-crf', '23',
-            '-movflags', '+faststart',
-        ];
-    };
+    try {
+        // Clean up old bundle cache
+        if (cachedBundle && cachedBundle.startsWith('/tmp/remotion-webpack-bundle-')) {
+            try {
+                await rm(cachedBundle, { recursive: true, force: true });
+            } catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+        
+        // Create bundle with explicit output configuration
+        cachedBundle = await bundle({
+            entryPoint: join(__dirname, 'remotion', 'index.tsx'),
+            webpackOverride: (config) => {
+                // Ensure bundle.js is created properly
+                config.output = {
+                    ...config.output,
+                    path: join(__dirname, 'dist'),
+                    filename: 'bundle.js',
+                    publicPath: '/',
+                };
+                
+                // Disable code splitting to ensure single bundle
+                config.optimization = {
+                    ...config.optimization,
+                    splitChunks: false,
+                    runtimeChunk: false,
+                };
+                
+                // Production optimizations
+                config.mode = 'production';
+                config.devtool = false;
+                
+                return config;
+            },
+            // Force fresh build
+            ignoreRegisterRootWarning: true,
+        });
+        
+        console.log(`[Bundle] Bundle created at: ${cachedBundle}`);
+        lastBundleTime = now;
+        return cachedBundle;
+    } catch (error) {
+        console.error('[Bundle] Error creating bundle:', error);
+        throw error;
+    }
 }
 
-// Calculate optimal concurrency
-async function getOptimalConcurrency() {
-    const os = await import('os');
-    const cpuCount = os.cpus().length;
-    return Math.min(cpuCount, 8);
+// Function to check if Chrome is available
+async function checkChrome() {
+    try {
+        const { execSync } = await import('child_process');
+        execSync(`${process.env.CHROME_BIN || '/usr/bin/google-chrome-stable'} --version`, { stdio: 'pipe' });
+        return true;
+    } catch (error) {
+        console.log('[Chrome] Chrome not found, will download headless shell');
+        return false;
+    }
 }
 
 // Render endpoint
@@ -129,8 +124,7 @@ app.post('/render', async (req, res) => {
     // 1. Respond immediately
     res.json({ 
         success: true, 
-        message: 'Rendering started in background',
-        gpu: isGpuAvailable() ? 'enabled' : 'disabled'
+        message: 'Rendering started in background'
     });
 
     // 2. Start Background Process
@@ -139,16 +133,58 @@ app.post('/render', async (req, res) => {
         
         try {
             console.log(`[Render] Starting render for project ${projectId}`);
-            console.log(`[Hardware] GPU: ${isGpuAvailable() ? 'Yes' : 'No'}`);
+
+            // Check Chrome before proceeding
+            const chromeAvailable = await checkChrome();
+            if (!chromeAvailable) {
+                console.log('[Chrome] Using Remotion headless shell');
+            }
 
             const bundleLocation = await getCachedBundle();
             console.log('[Bundle] Bundle ready');
 
+            // Verify bundle exists
+            try {
+                await readFile(join(bundleLocation, 'bundle.js'));
+                console.log('[Bundle] bundle.js verified');
+            } catch (error) {
+                console.error('[Bundle] bundle.js not found, checking alternative location');
+                // Try to find bundle.js in parent directory
+                const possiblePaths = [
+                    join(bundleLocation, 'bundle.js'),
+                    join(dirname(bundleLocation), 'bundle.js'),
+                    bundleLocation // In case it's already the file path
+                ];
+                
+                let found = false;
+                for (const path of possiblePaths) {
+                    try {
+                        await readFile(path);
+                        console.log(`[Bundle] Found at: ${path}`);
+                        found = true;
+                        break;
+                    } catch (e) {
+                        // Continue checking
+                    }
+                }
+                
+                if (!found) {
+                    throw new Error(`Bundle not found at ${bundleLocation}`);
+                }
+            }
+
             const composition = await selectComposition({
                 serveUrl: bundleLocation,
                 id: 'Main',
                 inputProps: { scenes, settings },
-                chromiumOptions: getChromiumOptions(),
+                chromiumOptions: {
+                    executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
+                    args: ['--no-sandbox', '--disable-dev-shm-usage'],
+                    // Prevent downloading if Chrome is available
+                    onBrowserDownload: chromeAvailable ? undefined : (progress) => {
+                        console.log(`[Chrome] Downloading headless shell: ${(progress.downloadedBytes / 1024 / 1024).toFixed(1)}Mb/${(progress.totalSize / 1024 / 1024).toFixed(1)}Mb`);
+                    }
+                },
             });
             
             console.log(`[Composition] Loaded: ${composition.durationInFrames} frames at ${composition.fps}fps`);
@@ -157,11 +193,6 @@ app.post('/render', async (req, res) => {
             await mkdir(tempDir, { recursive: true });
             const outputPath = join(tempDir, 'output.mp4');
 
-            const concurrency = await getOptimalConcurrency();
-            console.log(`[Concurrency] Using ${concurrency} threads`);
-
-            let lastLog = 0;
-            
             console.log('[Render] Starting video rendering...');
             
             await renderMedia({
@@ -173,19 +204,42 @@ app.post('/render', async (req, res) => {
                 imageFormat: 'jpeg',
                 jpegQuality: 80,
                 inputProps: { scenes, settings },
-                chromiumOptions: getChromiumOptions(),
-                concurrency: concurrency,
+                chromiumOptions: {
+                    executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
+                    args: ['--no-sandbox', '--disable-dev-shm-usage']
+                },
+                concurrency: 8, // Increased for L4
                 disallowParallelEncoding: false,
                 onProgress: ({ progress }) => {
                     const percent = Math.round(progress * 100);
-                    if (percent - lastLog >= 5 || percent === 100) {
-                        console.log(`[Progress] ${percent}%`);
-                        lastLog = percent;
+                    console.log(`[Progress] ${percent}%`);
+                },
+                ffmpegOverride: ({ args }) => {
+                    // Try to use NVENC if available
+                    try {
+                        const { execSync } = require('child_process');
+                        execSync('ffmpeg -encoders | grep nvenc', { stdio: 'pipe' });
+                        console.log('[FFmpeg] Using NVENC hardware encoding');
+                        return [
+                            ...args,
+                            '-c:v', 'h264_nvenc',
+                            '-preset', 'p1',
+                            '-cq', '23',
+                            '-movflags', '+faststart',
+                        ];
+                    } catch (e) {
+                        console.log('[FFmpeg] Using software encoding (libx264)');
+                        return [
+                            ...args,
+                            '-c:v', 'libx264',
+                            '-preset', 'fast',
+                            '-crf', '23',
+                            '-movflags', '+faststart',
+                        ];
                     }
                 },
-                ffmpegOverride: getFFmpegOverride(),
                 audioBitrate: '192k',
-                videoBitrate: '4M',
+                videoBitrate: '8M', // Higher for better quality
             });
 
             const renderTime = Date.now() - startTime;
@@ -237,7 +291,7 @@ app.post('/render', async (req, res) => {
             await rm(tempDir, { recursive: true, force: true });
 
         } catch (error) {
-            console.error(`[Render] Error for ${projectId}:`, error);
+            console.error(`[Render] Error for ${projectId}:`, error.message);
             
             // Update project status to 'error'
             try {
@@ -255,13 +309,27 @@ app.post('/render', async (req, res) => {
     })();
 });
 
-// Performance endpoint
+// Status endpoint
 app.get('/status', async (req, res) => {
     const os = await import('os');
+    const { execSync } = await import('child_process');
+    
+    let gpuInfo = 'Not detected';
+    try {
+        execSync('nvidia-smi --query-gpu=name --format=csv,noheader', { stdio: 'pipe' });
+        gpuInfo = 'NVIDIA GPU detected';
+    } catch (e) {
+        try {
+            execSync('lspci | grep -i vga', { stdio: 'pipe' });
+            gpuInfo = 'GPU detected (non-NVIDIA)';
+        } catch (e2) {
+            gpuInfo = 'No GPU detected';
+        }
+    }
     
     res.json({
         status: 'running',
-        gpu: isGpuAvailable(),
+        gpu: gpuInfo,
         cpu_cores: os.cpus().length,
         total_memory: Math.round(os.totalmem() / (1024 * 1024 * 1024)) + 'GB',
         free_memory: Math.round(os.freemem() / (1024 * 1024 * 1024)) + 'GB',
@@ -270,19 +338,54 @@ app.get('/status', async (req, res) => {
     });
 });
 
+// Warm-up endpoint to pre-download Chrome
+app.get('/warmup', async (req, res) => {
+    try {
+        console.log('[Warmup] Starting warm-up...');
+        await getCachedBundle();
+        console.log('[Warmup] Bundle ready');
+        
+        // Trigger Chrome check to pre-download if needed
+        await checkChrome();
+        console.log('[Warmup] Chrome ready');
+        
+        res.json({ status: 'warmed_up' });
+    } catch (error) {
+        console.error('[Warmup] Error:', error.message);
+        res.status(500).json({ error: error.message });
+    }
+});
+
 // Start server
-(async () => {
+app.listen(PORT, async () => {
+    console.log(`🎬 FacelessFlowAI Renderer running on port ${PORT}`);
+    
     const os = await import('os');
+    console.log(`💾 Memory: ${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`);
+    console.log(`⚡ CPU Cores: ${os.cpus().length}`);
     
-    app.listen(PORT, () => {
-        console.log(`🎬 FacelessFlowAI Renderer running on port ${PORT}`);
-        console.log(`⚡ GPU Available: ${isGpuAvailable() ? 'Yes' : 'No'}`);
-        console.log(`💾 Memory: ${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`);
-        
-        // Environment check
-        console.log('--- Environment ---');
-        console.log('CHROME_BIN:', process.env.CHROME_BIN || 'default');
-        console.log('COMPUTE_TYPE:', process.env.COMPUTE_TYPE || 'cpu');
-        console.log('------------------');
-    });
-})();
+    // Check GPU
+    try {
+        const { execSync } = await import('child_process');
+        const gpu = execSync('lspci | grep -i vga || echo "No GPU detected"', { encoding: 'utf8' });
+        console.log(`🎮 GPU: ${gpu.trim()}`);
+    } catch (e) {
+        console.log(`🎮 GPU: Not detected`);
+    }
+    
+    // Environment check
+    console.log('--- Environment ---');
+    console.log('CHROME_BIN:', process.env.CHROME_BIN || 'default');
+    console.log('COMPUTE_TYPE:', process.env.COMPUTE_TYPE || 'cpu');
+    console.log('------------------');
+    
+    // Auto-warmup
+    setTimeout(async () => {
+        try {
+            await getCachedBundle();
+            console.log('[Auto-Warmup] Bundle ready');
+        } catch (error) {
+            console.error('[Auto-Warmup] Failed:', error.message);
+        }
+    }, 5000);
+});