@agent-foundry/replay-server 1.0.0 → 1.0.2

package/scripts/test-service-sts.sh

@@ -0,0 +1,176 @@
+#!/bin/bash
+#
+# Test script for BFF /studio/service/sts endpoint
+#
+# This script tests the service-to-service authentication for obtaining
+# STS credentials from the BFF service.
+#
+# Usage:
+#   ./scripts/test-service-sts.sh
+#
+# Environment variables:
+#   BFF_BASE_URL       - BFF service URL (default: http://localhost:11001)
+#   BFF_SERVICE_TOKEN  - Set to SUPABASE_JWT_SECRET from BFF's .env
+#
+# The script will:
+#   1. Call POST /studio/service/sts with the service token
+#   2. Display the STS credentials (masked for security)
+#   3. Verify the response structure
+#
+
+set -e
+
+# Configuration
+BFF_BASE_URL="${BFF_BASE_URL:-http://localhost:11001}"
+BFF_SERVICE_TOKEN="${BFF_SERVICE_TOKEN:-}"
+
+echo "=============================================="
+echo "Testing BFF /studio/service/sts endpoint"
+echo "=============================================="
+echo ""
+echo "BFF URL: $BFF_BASE_URL"
+echo "Service Token: ${BFF_SERVICE_TOKEN:0:20}..."
+echo ""
+
+# Check if service token is configured
+if [ -z "$BFF_SERVICE_TOKEN" ]; then
+    echo "ERROR: BFF_SERVICE_TOKEN is not set"
+    echo ""
+    echo "Please set BFF_SERVICE_TOKEN to the value of SUPABASE_JWT_SECRET from BFF's .env file:"
+    echo ""
+    echo "  export BFF_SERVICE_TOKEN=your-supabase-jwt-secret"
+    echo ""
+    echo "Or add it to your .env file:"
+    echo ""
+    echo "  BFF_SERVICE_TOKEN=your-supabase-jwt-secret"
+    echo ""
+    exit 1
+fi
+
+# Test the endpoint
+echo "Calling POST $BFF_BASE_URL/studio/service/sts..."
+echo ""
+
+response=$(curl -s -w "\n%{http_code}" -X POST "$BFF_BASE_URL/studio/service/sts" \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer $BFF_SERVICE_TOKEN")
+
+# Extract HTTP status code (last line)
+http_code=$(echo "$response" | tail -n 1)
+# Extract body (all but last line)
+body=$(echo "$response" | sed '$d')
+
+echo "HTTP Status: $http_code"
+echo ""
+
+if [ "$http_code" -eq 200 ]; then
+    echo "SUCCESS! STS credentials received."
+    echo ""
+    
+    # Parse and display response (with masked secrets)
+    if command -v jq &> /dev/null; then
+        echo "Response:"
+        echo "$body" | jq '{
+            bucket: .bucket,
+            region: .region,
+            credentials: {
+                accessKeyId: (.credentials.accessKeyId | .[0:10] + "..."),
+                accessKeySecret: "***MASKED***",
+                securityToken: (.credentials.securityToken | .[0:20] + "..."),
+                expiration: .credentials.expiration
+            }
+        }'
+        
+        # Validate response structure
+        echo ""
+        echo "Validation:"
+        
+        has_bucket=$(echo "$body" | jq -r '.bucket // empty')
+        has_region=$(echo "$body" | jq -r '.region // empty')
+        has_access_key=$(echo "$body" | jq -r '.credentials.accessKeyId // empty')
+        has_secret=$(echo "$body" | jq -r '.credentials.accessKeySecret // empty')
+        has_token=$(echo "$body" | jq -r '.credentials.securityToken // empty')
+        has_expiration=$(echo "$body" | jq -r '.credentials.expiration // empty')
+        
+        all_valid=true
+        
+        if [ -n "$has_bucket" ]; then
+            echo "  [OK] bucket: $has_bucket"
+        else
+            echo "  [FAIL] bucket: missing"
+            all_valid=false
+        fi
+        
+        if [ -n "$has_region" ]; then
+            echo "  [OK] region: $has_region"
+        else
+            echo "  [FAIL] region: missing"
+            all_valid=false
+        fi
+        
+        if [ -n "$has_access_key" ]; then
+            echo "  [OK] credentials.accessKeyId: present"
+        else
+            echo "  [FAIL] credentials.accessKeyId: missing"
+            all_valid=false
+        fi
+        
+        if [ -n "$has_secret" ]; then
+            echo "  [OK] credentials.accessKeySecret: present"
+        else
+            echo "  [FAIL] credentials.accessKeySecret: missing"
+            all_valid=false
+        fi
+        
+        if [ -n "$has_token" ]; then
+            echo "  [OK] credentials.securityToken: present"
+        else
+            echo "  [FAIL] credentials.securityToken: missing"
+            all_valid=false
+        fi
+        
+        if [ -n "$has_expiration" ]; then
+            echo "  [OK] credentials.expiration: $has_expiration"
+        else
+            echo "  [FAIL] credentials.expiration: missing"
+            all_valid=false
+        fi
+        
+        echo ""
+        if [ "$all_valid" = true ]; then
+            echo "All validations passed!"
+            exit 0
+        else
+            echo "Some validations failed!"
+            exit 1
+        fi
+    else
+        echo "Response (raw):"
+        echo "$body"
+        echo ""
+        echo "Note: Install 'jq' for prettier output"
+    fi
+else
+    echo "FAILED! Error response:"
+    echo ""
+    if command -v jq &> /dev/null; then
+        echo "$body" | jq .
+    else
+        echo "$body"
+    fi
+    echo ""
+    
+    case $http_code in
+        401)
+            echo "Authentication failed. Check that BFF_SERVICE_TOKEN matches SUPABASE_JWT_SECRET in BFF."
+            ;;
+        500)
+            echo "Server error. Check BFF logs for details."
+            ;;
+        *)
+            echo "Unexpected error."
+            ;;
+    esac
+    
+    exit 1
+fi

package/src/cli/render.ts

@@ -9,8 +9,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { PuppeteerRenderer, RenderProgress } from '../renderer/PuppeteerRenderer.js';
-import type { ReplayManifestV1 } from '@agent-foundry/replay';
+import { PuppeteerRenderer, RenderProgress, GenericReplayManifest } from '../renderer/PuppeteerRenderer.js';
 
 interface CliArgs {
     manifest?: string;
@@ -130,7 +129,7 @@ Examples:
 `);
 }
 
-async function loadManifest(args: CliArgs): Promise<ReplayManifestV1> {
+async function loadManifest(args: CliArgs): Promise<GenericReplayManifest> {
     if (args.manifest) {
         const manifestPath = path.resolve(args.manifest);
         if (!fs.existsSync(manifestPath)) {
@@ -183,12 +182,24 @@ async function main(): Promise<void> {
         console.log('📄 Loading manifest...');
         const manifest = await loadManifest(args);
         console.log(`   Game ID: ${manifest.gameId}`);
-        console.log(`   Timeline: ${manifest.timeline.length} ages`);
-        console.log(`   Highlights: ${manifest.highlights.length}`);
+        
+        // Handle optional timeline
+        const timelineLength = Array.isArray(manifest.timeline) ? manifest.timeline.length : 0;
+        if (timelineLength > 0) {
+            console.log(`   Timeline: ${timelineLength} ages`);
+        }
+        
+        // Handle optional highlights
+        const highlightsLength = Array.isArray((manifest as any).highlights) ? (manifest as any).highlights.length : 0;
+        if (highlightsLength > 0) {
+            console.log(`   Highlights: ${highlightsLength}`);
+        }
 
         // Estimate duration
-        const estimatedDuration = manifest.timeline.length * args.secondsPerAge;
-        console.log(`   Estimated video duration: ${estimatedDuration}s`);
+        const estimatedDuration = timelineLength * args.secondsPerAge;
+        if (estimatedDuration > 0) {
+            console.log(`   Estimated video duration: ${estimatedDuration}s`);
+        }
         console.log('');
 
         // Create output directory

package/src/renderer/PuppeteerRenderer.ts

@@ -12,7 +12,38 @@
 import puppeteer, { Browser, Page } from 'puppeteer';
 import { spawn, ChildProcess } from 'child_process';
 import * as path from 'path';
-import type { ReplayManifestV1 } from '@agent-foundry/replay';
+
+/**
+ * Generic replay manifest interface
+ * Supports any game type - games interpret their own schemas
+ */
+export interface GenericReplayManifest {
+    schema: string;
+    bundleId?: string;
+    gameId: string;
+    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://) */
@@ -73,10 +104,59 @@ 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
      */
-    async render(manifest: ReplayManifestV1, config: RenderConfig): Promise<RenderResult> {
+    async render(manifest: GenericReplayManifest, config: RenderConfig): Promise<RenderResult> {
         const startTime = Date.now();
         const fullConfig: RenderConfig & typeof DEFAULT_CONFIG = {
             ...DEFAULT_CONFIG,
@@ -99,10 +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
-            const frameCount = manifest.timeline.length * 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`);
@@ -178,7 +263,7 @@ export class PuppeteerRenderer {
         });
     }
 
-    private async loadGame(gameUrl: string, manifest: ReplayManifestV1): Promise<void> {
+    private async loadGame(gameUrl: string, manifest: GenericReplayManifest): Promise<void> {
         if (!this.page) throw new Error('Browser not initialized');
 
         // Navigate to game with replay mode query parameter
@@ -194,23 +279,28 @@ export class PuppeteerRenderer {
 
         console.log('📼 Page loaded, waiting for React to initialize...');
 
-        // Wait for React to initialize (check for the app container)
+        // Wait for React to initialize
+        // Try to detect common app containers, but don't fail if not found
         try {
             await this.page.waitForFunction(() => {
-                // Wait for the app to be mounted and initial loading to complete
-                const app = document.querySelector('ion-app');
-                const loading = document.querySelector('ion-spinner');
-                return app !== null && loading === null;
-            }, { timeout: 15000 });
+                // Check for common app container patterns
+                const ionApp = document.querySelector('ion-app');
+                const rootDiv = document.querySelector('#root');
+                const appDiv = document.querySelector('[id*="app"], [class*="app"]');
+                
+                // If using Ionic, wait for loading to complete
+                if (ionApp) {
+                    const loading = document.querySelector('ion-spinner');
+                    return loading === null;
+                }
+                
+                // Otherwise, just check if root is mounted
+                return rootDiv !== null || appDiv !== null;
+            }, { timeout: 10000 });
+            console.log('📼 App container detected');
         } catch (error) {
-            // Log errors before failing
-            if (this.pageErrors.length > 0) {
-                console.error('📼 Page errors detected:', this.pageErrors);
-            }
-            if (this.failedRequests.length > 0) {
-                console.error('📼 Failed requests:', this.failedRequests);
-            }
-            throw error;
+            // Non-fatal - continue anyway
+            console.log('📼 App container detection timed out, continuing anyway...');
         }
 
         // Log any errors that occurred (but didn't prevent initialization)
@@ -275,32 +365,38 @@ export class PuppeteerRenderer {
      * Frames are captured as JPEG buffers and streamed directly to FFmpeg
      */
     private async captureAndEncodeFrames(
-        manifest: ReplayManifestV1,
+        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);
     }
 
     /**
      * Internal method to capture and encode with a specific encoder
      */
     private async captureAndEncodeFramesWithEncoder(
-        manifest: ReplayManifestV1,
+        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');
 
-        const totalAges = manifest.timeline.length;
-        const framesPerAge = config.secondsPerAge * config.fps;
-        const totalFrames = totalAges * framesPerAge;
+        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 = 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
@@ -376,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');
@@ -417,7 +510,7 @@ export class PuppeteerRenderer {
 
                     frameIndex++;
 
-                    // Update progress
+                    // Update progress every second
                     if (frameIndex % config.fps === 0) {
                         this.reportProgress(
                             onProgress,
@@ -428,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));
+                    }
                 }
             }