@agent-foundry/replay-server 1.0.0 → 1.0.1

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,18 @@
 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
+    [key: string]: unknown;
+}
 
 export interface RenderConfig {
     /** URL of the game (can be local file:// or http://) */
@@ -76,7 +87,7 @@ export class PuppeteerRenderer {
     /**
      * 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,
@@ -100,7 +111,9 @@ export class PuppeteerRenderer {
             await this.loadGame(fullConfig.gameUrl, manifest);
 
             // Capture and encode frames in streaming mode
-            const frameCount = manifest.timeline.length * fullConfig.secondsPerAge * fullConfig.fps;
+            // 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);
 
@@ -178,7 +191,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 +207,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,7 +293,7 @@ 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,
         onProgress?: (progress: RenderProgress) => void
     ): Promise<void> {
@@ -290,14 +308,16 @@ export class PuppeteerRenderer {
      * Internal method to capture and encode with a specific encoder
      */
     private async captureAndEncodeFramesWithEncoder(
-        manifest: ReplayManifestV1,
+        manifest: GenericReplayManifest,
         config: RenderConfig & typeof DEFAULT_CONFIG,
         encoder: 'h264_nvenc' | 'libx264',
         onProgress?: (progress: RenderProgress) => void
     ): Promise<void> {
         if (!this.page) throw new Error('Browser not initialized');
 
-        const totalAges = manifest.timeline.length;
+        // Handle optional timeline - games may not have timelines
+        const timelineLength = Array.isArray(manifest.timeline) ? manifest.timeline.length : 1;
+        const totalAges = timelineLength;
         const framesPerAge = config.secondsPerAge * config.fps;
         const totalFrames = totalAges * framesPerAge;