Update server.js

server.js

@@ -4,15 +4,12 @@ import express from 'express';
 import cors from 'cors';
 import { bundle } from '@remotion/bundler';
 import { renderMedia, selectComposition } from '@remotion/renderer';
-import { readFile, mkdir, rm, writeFile } from 'fs/promises';
+import { readFile, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join, dirname } from 'path';
-import { randomUUID } from 'crypto';
 import { fileURLToPath } from 'url';
-import { exec as execCallback } from 'child_process';
-import { promisify } from 'util';
+import os from 'os';
 
-const exec = promisify(execCallback);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
@@ -24,7 +21,7 @@ app.use(express.json({ limit: '50mb' }));
 
 // Health check
 app.get('/', (req, res) => {
-    res.json({ status: 'ok', service: 'FacelessFlowAI Video Renderer' });
+    res.json({ status: 'ok', service: 'FacelessFlowAI Video Renderer (Simple)' });
 });
 
 // Render endpoint
@@ -55,206 +52,67 @@ app.post('/render', async (req, res) => {
         try {
             console.log(`[Render] Starting background render for project ${projectId}`);
 
+            // Available resources
+            const cpuCount = os.cpus().length;
+            const freeMem = (os.freemem() / 1024 / 1024).toFixed(0);
+            const totalMem = (os.totalmem() / 1024 / 1024).toFixed(0);
+            console.log(`[Resources] vCPUs: ${cpuCount} | RAM: ${freeMem}/${totalMem} MB Free`);
+
             const bundleLocation = await bundle({
                 entryPoint: join(__dirname, 'remotion', 'index.tsx'),
                 webpackOverride: (config) => config,
             });
 
-            // --- STABILITY: Pre-download Assets ---
-            const fs = await import('fs');
-            const { pipeline } = await import('stream/promises');
-            const { createWriteStream } = await import('fs');
-
-            // Helper: Robust Downloader with Retries
-            const downloadAsset = async (url, destPath, retries = 3) => {
-                for (let i = 0; i < retries; i++) {
-                    try {
-                        const response = await fetch(url);
-                        if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
-                        if (!response.body) throw new Error(`No body for ${url}`);
-
-                        await pipeline(response.body, createWriteStream(destPath));
-                        return; // Success
-                    } catch (err) {
-                        console.warn(`[Download] Attempt ${i + 1} failed for ${url}: ${err.message}`);
-                        if (i === retries - 1) throw err; // Throw on last failure
-                        await new Promise(r => setTimeout(r, 2000 * (i + 1))); // Backoff
-                    }
-                }
-            };
-
-            // process.cwd() is disk-backed (prevents RAM OOM on HF Spaces)
-            const tempDir = join(process.cwd(), `temp_assets_${projectId}`);
-            try { await rm(tempDir, { recursive: true, force: true }); } catch { }
-            await mkdir(tempDir, { recursive: true });
-
-            console.log(`[Render] Pre-downloading assets to ${tempDir} (Disk-backed)...`);
-
-            // Helper: Batch Processor for Concurrency Control
-            const batchProcessArgs = async (items, batchSize, fn) => {
-                const results = [];
-                for (let i = 0; i < items.length; i += batchSize) {
-                    const batch = items.slice(i, i + batchSize);
-                    const batchResults = await Promise.all(batch.map((item, batchLocalIndex) => {
-                        const globalIndex = i + batchLocalIndex;
-                        return fn(item, globalIndex);
-                    }));
-                    results.push(...batchResults);
-                }
-                return results;
-            };
-
-            // Calculate total downloaded size using fs.stat
-            let totalBytes = 0;
-            const trackSize = async (file) => {
-                try {
-                    const stats = await fs.promises.stat(file);
-                    totalBytes += stats.size;
-                } catch { }
-            };
-
-            // Iterate scenes and download assets (Concurrency Limit: 5)
-            const localScenes = await batchProcessArgs(scenes, 5, async (scene, idx) => {
-                const newScene = { ...scene };
-
-                if (scene.audio_url) {
-                    const audioExt = scene.audio_url.split('.').pop().split('?')[0] || 'mp3';
-                    const localAudioPath = join(tempDir, `audio_${idx}.${audioExt}`);
-                    try {
-                        await downloadAsset(scene.audio_url, localAudioPath);
-                        await trackSize(localAudioPath);
-                        newScene.audio_url = `file://${localAudioPath}`;
-                    } catch (e) {
-                        console.error(`[Download] Failed audio for scene ${idx}: ${e.message}`);
-                    }
-                }
-
-                if (scene.image_url) {
-                    const isVideo = scene.media_type === 'video' || scene.image_url.includes('.mp4');
-                    const ext = isVideo ? 'mp4' : 'jpg';
-                    const localMediaPath = join(tempDir, `visual_${idx}.${ext}`);
-                    try {
-                        await downloadAsset(scene.image_url, localMediaPath);
-                        await trackSize(localMediaPath);
-                        newScene.image_url = `file://${localMediaPath}`;
-                    } catch (e) {
-                        console.error(`[Download] Failed visual for scene ${idx}: ${e.message}`);
-                    }
-                }
-                return newScene;
+            // Clean Composition Params
+            const composition = await selectComposition({
+                serveUrl: bundleLocation,
+                id: 'Main',
+                inputProps: { scenes, settings }, // Direct Cloud URLs
+                chromiumOptions: { executablePath: process.env.CHROME_BIN },
             });
 
-            console.log(`[Render] Download complete. Total asset size: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-
-            // 3. Mount temp dir statically so Remotion can fetch via HTTP (bypass file:// restriction)
-            const tempDirName = tempDir.split('/').pop();
-            app.use(`/tmp/${tempDirName}`, (req, res, next) => {
-                next();
-            }, express.static(tempDir));
-
-            console.log(`[Render] Assets mounted at /tmp/${tempDirName}. Starting Segmented Rendering...`);
-
-            // Rewrite scenes to use LOCALHOST HTTP URLs
-            const httpScenes = localScenes.map(s => {
-                const s2 = { ...s };
-                if (s2.audio_url && s2.audio_url.startsWith('file://')) {
-                    const filename = s2.audio_url.split('/').pop();
-                    s2.audio_url = `http://localhost:${PORT}/tmp/${tempDirName}/${filename}`;
-                }
-                if (s2.image_url && s2.image_url.startsWith('file://')) {
-                    const filename = s2.image_url.split('/').pop();
-                    s2.image_url = `http://localhost:${PORT}/tmp/${tempDirName}/${filename}`;
-                }
-                return s2;
+            const outputLocation = join(tmpdir(), `out-${projectId}.mp4`);
+
+            let lastLoggedPercent = -1;
+
+            // Simple Render
+            await renderMedia({
+                composition,
+                serveUrl: bundleLocation,
+                codec: 'h264',
+                pixelFormat: 'yuv420p',
+                outputLocation: outputLocation,
+                imageFormat: 'jpeg',
+                jpegQuality: 80,
+                inputProps: { scenes, settings },
+                chromiumOptions: {
+                    executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
+                    enableMultiProcessRendering: true, // Requested: Enable Multi-process
+                    args: [
+                        '--no-sandbox',
+                        '--disable-dev-shm-usage',
+                        '--disable-gpu',
+                        '--mute-audio',
+                    ]
+                },
+                // Use all available cores (or set specific number)
+                concurrency: 4,
+                disallowParallelEncoding: false,
+                onProgress: ({ progress }) => {
+                    const percent = Math.round(progress * 100);
+                    if (percent !== lastLoggedPercent && percent % 5 === 0) {
+                        console.log(`[Render] Progress: ${percent}%`);
+                        lastLoggedPercent = percent;
+                    }
+                },
             });
 
-            // --------------------------------------
-            // SEGMENTED BATCH RENDERING
-            // --------------------------------------
-            // CRASH FIX: Reduce batch size to 10 to prevent OOM
-            const BATCH_SIZE = 10;
-            const totalBatches = Math.ceil(httpScenes.length / BATCH_SIZE);
-            const partFiles = [];
-
-            const os = await import('os');
-            const cpuCount = os.cpus().length;
-            console.log(`[Render] Splitting ${httpScenes.length} scenes into ${totalBatches} parts. CPU: ${cpuCount}`);
-
-            for (let i = 0; i < totalBatches; i++) {
-                const startIdx = i * BATCH_SIZE;
-                const endIdx = Math.min((i + 1) * BATCH_SIZE, httpScenes.length);
-                const batchScenes = httpScenes.slice(startIdx, endIdx);
-
-                console.log(`[Render] Processing Part ${i + 1}/${totalBatches} (Scenes ${startIdx}-${endIdx - 1})...`);
-
-                const composition = await selectComposition({
-                    serveUrl: bundleLocation,
-                    id: 'Main',
-                    inputProps: { scenes: batchScenes, settings },
-                    chromiumOptions: { executablePath: process.env.CHROME_BIN },
-                });
-
-                const partPath = join(tempDir, `part_${i}.mp4`);
-                partFiles.push(partPath);
+            console.log(`[Render] Render complete. Uploading to Supabase...`);
 
-                let lastLoggedPercent = -1;
+            const videoBuffer = await readFile(outputLocation);
 
-                await renderMedia({
-                    composition,
-                    serveUrl: bundleLocation,
-                    codec: 'h264',
-                    pixelFormat: 'yuv420p',
-                    outputLocation: partPath,
-                    imageFormat: 'jpeg',
-                    jpegQuality: 80,
-                    inputProps: { scenes: batchScenes, settings },
-                    chromiumOptions: {
-                        executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
-                        enableMultiProcessRendering: true, // SPEED: Enable since we have 32GB RAM
-                        args: [
-                            '--no-sandbox',
-                            '--disable-dev-shm-usage',
-                            '--disable-gpu', // CPU Mode
-                            '--mute-audio',
-                        ]
-                    },
-                    concurrency: 2, // SPEED: 2x Parallel Frames
-                    disallowParallelEncoding: false, // SPEED: Allow parallel encoding
-                    onProgress: ({ progress }) => {
-                        const percent = Math.round(progress * 100);
-                        if (percent !== lastLoggedPercent && percent % 10 === 0) {
-                            console.log(`[Render] Part ${i + 1} Progress: ${percent}%`);
-                            lastLoggedPercent = percent;
-                        }
-                    },
-                });
-
-                console.log(`[Render] Part ${i + 1} Done.`);
-                // Clean composition object to help GC?
-            }
-
-            // --------------------------------------
-            // STITCHING
-            // --------------------------------------
-            console.log(`[Render] All parts rendered. Stitching ${partFiles.length} files...`);
-
-            const concatListPath = join(tempDir, 'concat_list.txt');
-            const concatContent = partFiles.map(p => `file '${p}'`).join('\n');
-            await writeFile(concatListPath, concatContent);
-
-            const finalOutputPath = join(tempDir, 'output_final.mp4');
-            const ffmpegCmd = `ffmpeg -f concat -safe 0 -i "${concatListPath}" -c copy "${finalOutputPath}"`;
-
-            await exec(ffmpegCmd);
-            console.log(`[Render] Stitching complete.`);
-
-            // --------------------------------------
-            // UPLOAD
-            // --------------------------------------
-            console.log(`[Render] Uploading to Supabase...`);
-            const videoBuffer = await readFile(finalOutputPath);
+            // Upload to Supabase Storage
             const fileName = `${projectId}/video-${Date.now()}.mp4`;
-
             const { data: uploadData, error: uploadError } = await supabase
                 .storage
                 .from('projects')
@@ -265,6 +123,7 @@ app.post('/render', async (req, res) => {
 
             if (uploadError) throw new Error(`Upload failed: ${uploadError.message}`);
 
+            // Get Public URL
             const { data: { publicUrl } } = supabase
                 .storage
                 .from('projects')
@@ -275,21 +134,26 @@ app.post('/render', async (req, res) => {
             // Update Project in DB
             const { error: dbError } = await supabase
                 .from('projects')
-                .update({ status: 'done', video_url: publicUrl })
+                .update({
+                    status: 'done',
+                    video_url: publicUrl
+                })
                 .eq('id', projectId);
 
             if (dbError) throw new Error(`DB Update failed: ${dbError.message}`);
 
-            console.log(`[Render] Project ${projectId} completed and updated.`);
+            console.log(`[Render] Project ${projectId} updated successfully`);
 
             // Cleanup
-            await rm(tempDir, { recursive: true, force: true });
+            await rm(outputLocation, { force: true });
 
         } catch (error) {
             console.error(`[Render] Background Error for ${projectId}:`, error);
             await supabase
                 .from('projects')
-                .update({ status: 'error' })
+                .update({
+                    status: 'error',
+                })
                 .eq('id', projectId);
         }
     })();