@agent-foundry/replay-server 1.0.1 → 1.0.2

package/scripts/test-bundle-preload.sh

@@ -2,7 +2,7 @@
 
 SERVER_URL="http://localhost:3001"
 BUNDLE_ID="game-jump-arena"
-BUNDLE_URL="https://agent-foundry.oss-cn-beijing.aliyuncs.com/studio-bundles/92922750-9ea6-4fc7-aeef-a13b8cc9eae5/game-jump-arena/2026.01.24-104533/bundle-1769251533018.tar.gz"
+BUNDLE_URL="https://agent-foundry.oss-cn-beijing.aliyuncs.com/studio-bundles/92922750-9ea6-4fc7-aeef-a13b8cc9eae5/game-jump-arena/2026.01.24-160727/bundle-1769270846565.tar.gz"
 
 set -x
 
@@ -17,4 +17,4 @@ curl -s -X POST "$SERVER_URL/api/bundles/preload" \
 
 
 sleep 5
-curl -s "http://$SERVER_URL/api/bundles"
+curl -s "$SERVER_URL/api/bundles"

package/src/renderer/PuppeteerRenderer.ts

@@ -21,10 +21,30 @@ export interface GenericReplayManifest {
     schema: string;
     bundleId?: string;
     gameId: string;
-    timeline?: unknown[]; // Optional - games may not have timelines
+    timeline?: unknown[]; // Optional - games may not have timelines (LifeRestart uses this)
+    summary?: {
+        durationSeconds?: number; // JumpArena provides duration directly
+        [key: string]: unknown;
+    };
     [key: string]: unknown;
 }
 
+/**
+ * Replay mode determines how frames are captured:
+ * - 'age-based': Discrete ages with replay-next-age events (LifeRestart)
+ * - 'continuous': Real-time simulation without events (JumpArena)
+ */
+type ReplayMode = 'age-based' | 'continuous';
+
+/**
+ * Replay timing configuration calculated from manifest
+ */
+interface ReplayTiming {
+    mode: ReplayMode;
+    durationSeconds: number;
+    totalFrames: number;
+}
+
 export interface RenderConfig {
     /** URL of the game (can be local file:// or http://) */
     gameUrl: string;
@@ -84,6 +104,55 @@ export class PuppeteerRenderer {
     private pageErrors: string[] = [];
     private failedRequests: Array<{ url: string; errorText?: string }> = [];
 
+    /**
+     * Calculate replay timing based on manifest fields
+     * 
+     * Detection priority (field-based, not schema-name based):
+     * 1. If manifest.summary.durationSeconds exists → continuous mode
+     * 2. If manifest.timeline[] exists → age-based mode  
+     * 3. Fallback to 10s continuous mode
+     * 
+     * Continuous mode: Real-time simulation, frames captured at regular intervals
+     * Age-based mode: Discrete ages with replay-next-age events
+     */
+    private calculateReplayTiming(
+        manifest: GenericReplayManifest,
+        config: { fps: number; secondsPerAge: number }
+    ): ReplayTiming {
+        // Priority 1: Check for summary.durationSeconds (continuous mode)
+        const durationSeconds = manifest.summary?.durationSeconds;
+        if (typeof durationSeconds === 'number' && durationSeconds > 0) {
+            const totalFrames = Math.ceil(durationSeconds * config.fps);
+            console.log(`📼 Continuous mode (durationSeconds): ${durationSeconds.toFixed(2)}s, ${totalFrames} frames`);
+            return {
+                mode: 'continuous',
+                durationSeconds,
+                totalFrames,
+            };
+        }
+
+        // Priority 2: Check for timeline[] (age-based mode)
+        if (Array.isArray(manifest.timeline) && manifest.timeline.length > 0) {
+            const timelineLength = manifest.timeline.length;
+            const duration = timelineLength * config.secondsPerAge;
+            const totalFrames = Math.ceil(duration * config.fps);
+            console.log(`📼 Age-based mode (timeline): ${timelineLength} ages, ${duration.toFixed(2)}s, ${totalFrames} frames`);
+            return {
+                mode: 'age-based',
+                durationSeconds: duration,
+                totalFrames,
+            };
+        }
+
+        // Fallback: No duration info, use default continuous mode
+        console.warn('📼 No duration info in manifest, using default 10s continuous mode');
+        return {
+            mode: 'continuous',
+            durationSeconds: 10,
+            totalFrames: Math.ceil(10 * config.fps),
+        };
+    }
+
     /**
      * Render a replay manifest to video
      */
@@ -110,12 +179,15 @@ export class PuppeteerRenderer {
             this.reportProgress(config.onProgress, 'init', 0, 1, 'Loading game...');
             await this.loadGame(fullConfig.gameUrl, manifest);
 
+            // Calculate timing based on manifest schema
+            const timing = this.calculateReplayTiming(manifest, {
+                fps: fullConfig.fps,
+                secondsPerAge: fullConfig.secondsPerAge,
+            });
+
             // Capture and encode frames in streaming mode
-            // Handle optional timeline - games may not have timelines
-            const timelineLength = Array.isArray(manifest.timeline) ? manifest.timeline.length : 1;
-            const frameCount = timelineLength * fullConfig.secondsPerAge * fullConfig.fps;
-            this.reportProgress(config.onProgress, 'capture', 0, frameCount, 'Starting capture & encode...');
-            await this.captureAndEncodeFrames(manifest, fullConfig, config.onProgress);
+            this.reportProgress(config.onProgress, 'capture', 0, timing.totalFrames, 'Starting capture & encode...');
+            await this.captureAndEncodeFrames(manifest, fullConfig, timing, config.onProgress);
 
             const duration = (Date.now() - startTime) / 1000;
             this.reportProgress(config.onProgress, 'complete', 1, 1, `Completed in ${duration.toFixed(1)}s`);
@@ -295,13 +367,14 @@ export class PuppeteerRenderer {
     private async captureAndEncodeFrames(
         manifest: GenericReplayManifest,
         config: RenderConfig & typeof DEFAULT_CONFIG,
+        timing: ReplayTiming,
         onProgress?: (progress: RenderProgress) => void
     ): Promise<void> {
         // Use encoder based on configuration
         const encoder = config.useHardwareAcceleration ? 'h264_nvenc' : 'libx264';
         console.log(`📼 Using encoder: ${encoder} (Hardware acceleration: ${config.useHardwareAcceleration ? 'enabled' : 'disabled'})`);
 
-        await this.captureAndEncodeFramesWithEncoder(manifest, config, encoder, onProgress);
+        await this.captureAndEncodeFramesWithEncoder(manifest, config, timing, encoder, onProgress);
     }
 
     /**
@@ -310,17 +383,20 @@ export class PuppeteerRenderer {
     private async captureAndEncodeFramesWithEncoder(
         manifest: GenericReplayManifest,
         config: RenderConfig & typeof DEFAULT_CONFIG,
+        timing: ReplayTiming,
         encoder: 'h264_nvenc' | 'libx264',
         onProgress?: (progress: RenderProgress) => void
     ): Promise<void> {
         if (!this.page) throw new Error('Browser not initialized');
 
-        // Handle optional timeline - games may not have timelines
+        const { mode, totalFrames, durationSeconds } = timing;
+        
+        // For age-based mode, calculate ages and frames per age
         const timelineLength = Array.isArray(manifest.timeline) ? manifest.timeline.length : 1;
         const totalAges = timelineLength;
-        const framesPerAge = config.secondsPerAge * config.fps;
-        const totalFrames = totalAges * framesPerAge;
+        const framesPerAge = Math.ceil(config.secondsPerAge * config.fps);
 
+        console.log(`📼 Replay mode: ${mode}, duration: ${durationSeconds.toFixed(2)}s, frames: ${totalFrames}`);
         console.log(`📼 Using encoder: ${encoder}`);
 
         // Launch FFmpeg process with stdin input
@@ -396,18 +472,15 @@ export class PuppeteerRenderer {
         }
 
         try {
-            // Capture and stream frames
-            for (let ageIndex = 0; ageIndex < totalAges; ageIndex++) {
-                // Advance to next age in the game
-                await this.page.evaluate(() => {
-                    window.dispatchEvent(new CustomEvent('replay-next-age'));
-                });
+            // Frame interval in ms (for continuous mode timing)
+            const frameIntervalMs = 1000 / config.fps;
 
-                // Wait a bit for animation
-                await new Promise(resolve => setTimeout(resolve, 100));
+            if (mode === 'continuous') {
+                // CONTINUOUS MODE: Capture frames at regular intervals
+                // Game runs in real-time, we just capture screenshots
+                console.log(`📼 Continuous mode: capturing ${totalFrames} frames over ${durationSeconds.toFixed(2)}s`);
 
-                // Capture frames for this age
-                for (let f = 0; f < framesPerAge; f++) {
+                for (let f = 0; f < totalFrames; f++) {
                     // Check if FFmpeg process has closed unexpectedly
                     if (ffmpegClosed) {
                         throw new Error('FFmpeg process closed unexpectedly');
@@ -437,7 +510,7 @@ export class PuppeteerRenderer {
 
                     frameIndex++;
 
-                    // Update progress
+                    // Update progress every second
                     if (frameIndex % config.fps === 0) {
                         this.reportProgress(
                             onProgress,
@@ -448,8 +521,68 @@ export class PuppeteerRenderer {
                         );
                     }
 
-                    // Small delay between frames
-                    await new Promise(resolve => setTimeout(resolve, 1000 / config.fps / 2));
+                    // Wait for next frame interval (allow game to advance simulation)
+                    await new Promise(resolve => setTimeout(resolve, frameIntervalMs));
+                }
+            } else {
+                // AGE-BASED MODE: Dispatch replay-next-age for each age
+                // Used by LifeRestart and similar games
+                console.log(`📼 Age-based mode: ${totalAges} ages, ${framesPerAge} frames per age`);
+
+                for (let ageIndex = 0; ageIndex < totalAges; ageIndex++) {
+                    // Advance to next age in the game
+                    await this.page.evaluate(() => {
+                        window.dispatchEvent(new CustomEvent('replay-next-age'));
+                    });
+
+                    // Wait a bit for animation
+                    await new Promise(resolve => setTimeout(resolve, 100));
+
+                    // Capture frames for this age
+                    for (let f = 0; f < framesPerAge; f++) {
+                        // Check if FFmpeg process has closed unexpectedly
+                        if (ffmpegClosed) {
+                            throw new Error('FFmpeg process closed unexpectedly');
+                        }
+
+                        // Capture screenshot as JPEG buffer
+                        const screenshotBuffer = await this.page.screenshot({
+                            type: 'jpeg',
+                            quality: 85,
+                            encoding: 'binary',
+                        }) as Buffer;
+
+                        // Write frame to FFmpeg stdin
+                        if (ffmpeg.stdin && !ffmpeg.stdin.destroyed) {
+                            const writeSuccess = ffmpeg.stdin.write(screenshotBuffer);
+                            if (!writeSuccess) {
+                                // Wait for drain event if buffer is full
+                                await new Promise<void>((resolve) => {
+                                    if (ffmpeg.stdin) {
+                                        ffmpeg.stdin.once('drain', resolve);
+                                    } else {
+                                        resolve();
+                                    }
+                                });
+                            }
+                        }
+
+                        frameIndex++;
+
+                        // Update progress
+                        if (frameIndex % config.fps === 0) {
+                            this.reportProgress(
+                                onProgress,
+                                'capture',
+                                frameIndex,
+                                totalFrames,
+                                `Capturing & encoding frame ${frameIndex}/${totalFrames} (${encoder})`
+                            );
+                        }
+
+                        // Small delay between frames
+                        await new Promise(resolve => setTimeout(resolve, frameIntervalMs / 2));
+                    }
                 }
             }