Update server.js

server.js

@@ -1,8 +1,8 @@
 import express from 'express';
 import cors from 'cors';
 import { bundle } from '@remotion/bundler';
-import { renderFrames, stitchFramesToVideo } from '@remotion/renderer';
-import { readFile, mkdir, rm, writeFile } from 'fs/promises';
+import { renderMedia, selectComposition } from '@remotion/renderer';
+import { readFile, mkdir, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join, dirname } from 'path';
 import { randomUUID } from 'crypto';
@@ -17,362 +17,533 @@ const PORT = process.env.PORT || 7860;
 app.use(cors());
 app.use(express.json({ limit: '50mb' }));
 
-// Global cache for bundle
-let cachedBundle = null;
-let lastBundleTime = 0;
-const BUNDLE_CACHE_TTL = 5 * 60 * 1000;
+// 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',
-        note: 'Custom rendering pipeline with NVENC'
+        version: '2.0.0',
+        uptime: Math.round(process.uptime())
     });
 });
 
-// Get bundle with caching
-async function getCachedBundle() {
+// Professional bundle management
+async function getBundle() {
     const now = Date.now();
     
-    if (cachedBundle && (now - lastBundleTime) < BUNDLE_CACHE_TTL) {
-        console.log('[Performance] Using cached bundle');
-        return cachedBundle;
+    if (cachedBundle.location && (now - cachedBundle.timestamp) < BUNDLE_CACHE_TTL) {
+        console.log('[Bundle] Using cached bundle');
+        return cachedBundle.location;
     }
     
-    console.log('[Performance] Creating new bundle');
+    console.log('[Bundle] Creating production bundle');
     
     try {
-        cachedBundle = await bundle({
+        cachedBundle.location = await bundle({
             entryPoint: join(__dirname, 'remotion', 'index.tsx'),
+            // Professional webpack configuration
             webpackOverride: (config) => {
-                config.output = {
-                    ...config.output,
-                    filename: 'bundle.js',
-                    publicPath: '/',
-                };
+                // Production optimizations
+                config.mode = 'production';
+                config.devtool = false;
                 
+                // Bundle optimizations
                 config.optimization = {
-                    ...config.optimization,
-                    splitChunks: false,
-                    runtimeChunk: false,
+                    minimize: true,
+                    moduleIds: 'deterministic',
+                    splitChunks: {
+                        chunks: 'async',
+                        minSize: 20000,
+                        maxSize: 70000,
+                    },
                 };
                 
-                config.mode = 'production';
-                config.devtool = false;
+                // Performance hints
+                config.performance = {
+                    hints: false,
+                    maxEntrypointSize: 512000,
+                    maxAssetSize: 512000,
+                };
                 
                 return config;
             },
         });
         
-        console.log(`[Bundle] Bundle created at: ${cachedBundle}`);
-        lastBundleTime = now;
-        return cachedBundle;
+        cachedBundle.timestamp = now;
+        cachedBundle.version++;
+        
+        console.log(`[Bundle] Bundle v${cachedBundle.version} ready at ${cachedBundle.location}`);
+        return cachedBundle.location;
     } catch (error) {
-        console.error('[Bundle] Error creating bundle:', error);
+        console.error('[Bundle] Failed to create bundle:', error);
         throw error;
     }
 }
 
-// Custom video stitching with system FFmpeg
-async function stitchFramesWithNVENC(frameDir, fps, outputPath, width = 1920, height = 1080) {
-    const { exec } = await import('child_process');
-    const { promisify } = await import('util');
-    const execAsync = promisify(exec);
-    
-    try {
-        console.log('[NVENC] Starting hardware encoding with system FFmpeg');
+// Professional rendering configuration
+function getRenderConfig() {
+    return {
+        // Video settings
+        codec: 'h264' as const,
+        pixelFormat: 'yuv420p' as const,
+        imageFormat: 'jpeg' as const,
+        jpegQuality: 80,
         
-        // First, check if NVENC is available
-        const { stdout: encoderCheck } = await execAsync('ffmpeg -encoders 2>&1 | grep -i nvenc');
-        const hasNVENC = encoderCheck.includes('h264_nvenc');
+        // Performance settings (optimized for L4: 8 vCPU, 30GB RAM)
+        concurrency: 6, // Optimal for 8-core system
+        disallowParallelEncoding: false,
+        numberOfGifLoops: 0,
         
-        if (hasNVENC) {
-            console.log('[NVENC] Using hardware encoding');
-            
-            // Build FFmpeg command for NVENC
-            const ffmpegCmd = [
-                'ffmpeg',
-                '-y', // Overwrite output
-                '-framerate', String(fps),
-                '-i', `${frameDir}/%d.png`, // Input frames
-                '-c:v', 'h264_nvenc', // NVENC encoder
-                '-preset', 'p1', // Fastest quality preset
-                '-cq', '20', // Constant quality
-                '-movflags', '+faststart',
-                '-pix_fmt', 'yuv420p',
-                '-vf', `scale=${width}:${height}:flags=lanczos`,
-                '-c:a', 'aac',
-                '-b:a', '192k',
-                outputPath
-            ].join(' ');
-            
-            console.log(`[NVENC] Command: ${ffmpegCmd}`);
-            
-            const { stdout, stderr } = await execAsync(ffmpegCmd, { maxBuffer: 1024 * 1024 * 50 });
-            console.log('[NVENC] Encoding completed');
-            
-        } else {
-            console.log('[NVENC] Falling back to software encoding');
-            
-            // Fallback to software encoding
-            const ffmpegCmd = [
-                'ffmpeg',
-                '-y',
-                '-framerate', String(fps),
-                '-i', `${frameDir}/%d.png`,
-                '-c:v', 'libx264',
-                '-preset', 'fast',
-                '-crf', '23',
-                '-movflags', '+faststart',
-                '-pix_fmt', 'yuv420p',
-                '-vf', `scale=${width}:${height}:flags=lanczos`,
-                '-c:a', 'aac',
-                '-b:a', '192k',
-                outputPath
-            ].join(' ');
-            
-            const { stdout, stderr } = await execAsync(ffmpegCmd, { maxBuffer: 1024 * 1024 * 50 });
-            console.log('[Software] Encoding completed');
-        }
+        // Audio settings
+        audioBitrate: '192k',
+        videoBitrate: '8M',
+        muted: false,
         
-        return true;
+        // 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',
+            ],
+        },
         
-    } catch (error) {
-        console.error('[Encoding] Error:', error.message);
-        throw error;
+        // FFmpeg settings (professional defaults)
+        ffmpegOverride: undefined, // Let Remotion handle FFmpeg
+    };
+}
+
+// Professional error handling
+class RenderError extends Error {
+    constructor(message, public code: string, public details?: any) {
+        super(message);
+        this.name = 'RenderError';
     }
 }
 
-// Custom render pipeline
-async function customRender(composition, bundleLocation, scenes, settings, outputPath) {
-    const startTime = Date.now();
-    
-    console.log('[Custom Render] Starting frame rendering...');
-    
-    // Step 1: Render frames
-    const frameDir = join(tmpdir(), `frames-${randomUUID()}`);
-    await mkdir(frameDir, { recursive: true });
-    
-    const renderStart = Date.now();
+// Main render function (professional pattern)
+async function renderVideo(params: {
+    compositionId: string;
+    serveUrl: string;
+    inputProps: any;
+    onProgress?: (progress: number) => void;
+}) {
+    const { compositionId, serveUrl, inputProps, onProgress } = params;
     
-    await renderFrames({
-        config: composition,
-        serveUrl: bundleLocation,
-        onStart: ({ frameCount }) => {
-            console.log(`[Frames] Rendering ${frameCount} frames`);
-        },
-        onFrameUpdate: ({ renderedFrames, encodedFrames }) => {
-            const percent = Math.round((renderedFrames / composition.durationInFrames) * 100);
-            const elapsed = (Date.now() - renderStart) / 1000;
-            const fps = elapsed > 0 ? Math.round(renderedFrames / elapsed) : 0;
-            console.log(`[Frames] ${percent}% | FPS: ${fps} | Rendered: ${renderedFrames}/${composition.durationInFrames}`);
-        },
-        outputDir: frameDir,
-        inputProps: { scenes, settings },
-        imageFormat: 'png',
-        compositionId: composition.id,
-        concurrency: 6,
-        chromiumOptions: {
-            executablePath: '/usr/bin/google-chrome-stable',
-            args: ['--no-sandbox', '--disable-dev-shm-usage']
-        },
+    console.log('[Render] Selecting composition...');
+    const composition = await selectComposition({
+        serveUrl,
+        id: compositionId,
+        inputProps,
+        chromiumOptions: getRenderConfig().chromiumOptions,
     });
     
-    const frameTime = Date.now() - renderStart;
-    console.log(`[Frames] Completed in ${Math.round(frameTime / 1000)}s`);
+    console.log(`[Render] Composition: ${composition.durationInFrames} frames @ ${composition.fps}fps`);
     
-    // Step 2: Stitch frames with NVENC
-    console.log('[Custom Render] Stitching frames to video...');
-    const stitchStart = Date.now();
+    const tempDir = join(tmpdir(), `render-${randomUUID()}`);
+    await mkdir(tempDir, { recursive: true });
+    const outputPath = join(tempDir, 'output.mp4');
     
-    await stitchFramesWithNVENC(
-        frameDir,
-        composition.fps,
-        outputPath,
-        composition.width,
-        composition.height
-    );
+    const renderConfig = getRenderConfig();
     
-    const stitchTime = Date.now() - stitchStart;
-    console.log(`[Stitching] Completed in ${Math.round(stitchTime / 1000)}s`);
+    console.log('[Render] Starting render...');
     
-    // Step 3: Cleanup frames
-    await rm(frameDir, { recursive: true, force: true });
-    
-    const totalTime = Date.now() - startTime;
-    console.log(`[Custom Render] Total time: ${Math.round(totalTime / 1000)}s`);
+    const startTime = Date.now();
+    let lastProgress = 0;
     
-    return totalTime;
+    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;
+                    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,
+            fileSizeMB,
+            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
+// Render endpoint (professional API design)
 app.post('/render', async (req, res) => {
     const { projectId, scenes, settings } = req.body;
-
+    
+    // Input validation
     if (!projectId || !scenes || !settings) {
-        return res.status(400).json({ error: 'Missing projectId, scenes, or settings' });
+        return res.status(400).json({
+            error: 'VALIDATION_ERROR',
+            message: 'Missing required fields: projectId, scenes, or settings',
+            required: ['projectId', 'scenes', 'settings']
+        });
     }
-
-    // Initialize Supabase Admin Client
+    
+    // Initialize Supabase
     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) {
-        console.error('[Config] Missing Supabase credentials');
-        return res.status(500).json({ error: 'Renderer configuration error' });
+        return res.status(500).json({
+            error: 'CONFIGURATION_ERROR',
+            message: 'Server configuration error'
+        });
     }
-
+    
     const { createClient } = await import('@supabase/supabase-js');
     const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY);
-
-    // 1. Respond immediately
-    res.json({ 
-        success: true, 
-        message: 'Rendering started in background',
-        note: 'Using custom render pipeline with hardware acceleration'
+    
+    // Accept request immediately (async processing)
+    res.json({
+        success: true,
+        message: 'Render job accepted',
+        jobId: projectId,
+        estimatedTime: 'Processing...'
     });
-
-    // 2. Start Background Process
+    
+    // Start async processing
     (async () => {
-        const startTime = Date.now();
-        
         try {
-            console.log(`[Render] Starting render for project ${projectId}`);
-
-            const bundleLocation = await getCachedBundle();
-            console.log('[Bundle] Bundle ready');
-
-            const composition = await import('@remotion/renderer').then(mod => 
-                mod.selectComposition({
-                    serveUrl: bundleLocation,
-                    id: 'Main',
-                    inputProps: { scenes, settings },
-                    chromiumOptions: {
-                        executablePath: '/usr/bin/google-chrome-stable',
-                        args: ['--no-sandbox', '--disable-dev-shm-usage']
-                    },
+            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);
             
-            console.log(`[Composition] Loaded: ${composition.durationInFrames} frames at ${composition.fps}fps`);
-
-            const tempDir = join(tmpdir(), `remotion-${randomUUID()}`);
-            await mkdir(tempDir, { recursive: true });
-            const outputPath = join(tempDir, 'output.mp4');
-
-            console.log('[Render] Starting custom render pipeline...');
+            // Get bundle
+            const bundleLocation = await getBundle();
+            
+            // Render video
+            const result = await renderVideo({
+                compositionId: 'Main',
+                serveUrl: bundleLocation,
+                inputProps: { scenes, settings },
+                onProgress: (progress) => {
+                    // Optional: Send progress updates via WebSocket or store in DB
+                    console.log(`[Job ${projectId}] Progress: ${Math.round(progress * 100)}%`);
+                }
+            });
             
-            const renderTime = await customRender(
-                composition,
-                bundleLocation,
-                scenes,
-                settings,
-                outputPath
-            );
-
-            console.log(`[Render] Completed in ${Math.round(renderTime / 1000)}s`);
-
-            console.log(`[Upload] Reading video file...`);
-            const videoBuffer = await readFile(outputPath);
-            console.log(`[Upload] Video size: ${Math.round(videoBuffer.length / (1024 * 1024))}MB`);
-
             // Upload to Supabase Storage
-            const fileName = `${projectId}/video-${Date.now()}.mp4`;
-            const { data: uploadData, error: uploadError } = await 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, videoBuffer, {
-                    contentType: 'video/mp4',
-                    upsert: true
+                .upload(fileName, result.buffer, {
+                    contentType,
+                    cacheControl: '3600',
+                    upsert: false
                 });
-
-            if (uploadError) {
-                console.error('[Upload] Error:', uploadError);
-                throw new Error(`Upload failed: ${uploadError.message}`);
-            }
-
-            // Get Public URL
-            const { data: { publicUrl } } = supabase
-                .storage
+            
+            if (uploadError) throw uploadError;
+            
+            // Get public URL
+            const { data: { publicUrl } } = supabase.storage
                 .from('projects')
                 .getPublicUrl(fileName);
-
-            console.log(`[Upload] Uploaded to ${publicUrl}`);
-
-            // Update Project in DB
-            const { error: dbError } = await supabase
+            
+            // Update project with success
+            await supabase
                 .from('projects')
                 .update({
-                    status: 'done',
+                    status: 'completed',
                     video_url: publicUrl,
-                    render_time: renderTime,
-                    rendered_at: new Date().toISOString()
+                    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()
+                    }
                 })
                 .eq('id', projectId);
-
-            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 });
-
+            
+            console.log(`[Job ${projectId}] Completed successfully`);
+            
         } catch (error) {
-            console.error(`[Render] Error for ${projectId}:`, error.message);
+            console.error(`[Job ${projectId}] Failed:`, error);
             
-            // Update project status to 'error'
+            // Update with error
             try {
                 await supabase
                     .from('projects')
                     .update({
-                        status: 'error',
-                        error_message: error.message
+                        status: 'failed',
+                        error_message: error.message,
+                        error_details: error.details || {},
+                        failed_at: new Date().toISOString()
                     })
                     .eq('id', projectId);
             } catch (dbError) {
-                console.error('[DB] Failed to update error status:', dbError);
+                console.error(`[Job ${projectId}] Failed to update error status:`, dbError);
             }
         }
     })();
 });
 
-// Status endpoint
+// 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 });
+    }
+});
+
+// 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: 'running',
-        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',
-        bundle_cached: cachedBundle !== null,
-        uptime: Math.round(process.uptime()) + 's',
-        render_method: 'Custom pipeline with hardware acceleration'
+        status: anyError ? 'degraded' : (allHealthy ? 'healthy' : 'warning'),
+        checks,
+        timestamp: new Date().toISOString()
     });
 });
 
 // Start server
-app.listen(PORT, async () => {
-    console.log(`🎬 FacelessFlowAI Renderer running on port ${PORT}`);
+app.listen(PORT, () => {
+    console.log(`
+    🎬 FacelessFlowAI Professional Renderer
+    ======================================
+    Port: ${PORT}
+    Mode: Production
+    Hardware: L4 GPU (8 vCPU, 30GB RAM)
     
-    const os = await import('os');
-    console.log(`💾 Memory: ${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`);
-    console.log(`⚡ CPU Cores: ${os.cpus().length}`);
+    Endpoints:
+    - GET  /           Service status
+    - GET  /health     System health check
+    - GET  /status     Detailed service info
+    - GET  /metrics    System metrics
+    - POST /render     Render video
     
-    console.log('--- Configuration ---');
-    console.log('RENDER: Custom pipeline (renderFrames + FFmpeg)');
-    console.log('ENCODING: Hardware NVENC when available');
-    console.log('FRAMES: PNG format for quality');
-    console.log('---------------------');
+    Initializing...
+    `);
     
-    // Auto-warmup
+    // Warm up the system
     setTimeout(async () => {
         try {
-            await getCachedBundle();
-            console.log('[Auto-Warmup] Bundle ready');
+            console.log('[Init] Warming up renderer...');
+            await getBundle();
+            console.log('[Init] Renderer ready');
         } catch (error) {
-            console.error('[Auto-Warmup] Failed:', error.message);
+            console.error('[Init] Warmup failed:', error.message);
         }
-    }, 3000);
+    }, 2000);
 });