@agent-foundry/replay-server 1.0.0 → 1.0.2

package/src/server/index.ts

@@ -1,14 +1,18 @@
 /**
  * Replay Render Server
- * 
+ *
  * HTTP API for rendering replays to video
- * 
+ *
  * Endpoints:
  * - POST /render - Start a render job
  * - GET /jobs - List all jobs
  * - GET /status/:jobId - Get job status
  * - GET /download/:jobId - Download completed video
  * - GET /bundles - List available game bundles
+ * - POST /bundles/preload - Preload a bundle
+ * - GET /bundles/stats - Get cache statistics
+ * - GET /bundles/:bundleId - Get specific bundle info
+ * - DELETE /bundles/:bundleId - Remove bundle from cache
  */
 
 import express, { type Express } from 'express';
@@ -20,6 +24,8 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { execSync } from 'child_process';
 import { PuppeteerRenderer, RenderProgress } from '../renderer/PuppeteerRenderer.js';
+import { OSSClient, createOSSClient } from '../services/OSSClient.js';
+import { BundleManager, createBundleManager, BundleManagerError } from '../services/BundleManager.js';
 import type { ReplayManifestV1 } from '@agent-foundry/replay';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -33,50 +39,184 @@ const PORT = process.env.PORT || 3001;
 const GAME_URL = process.env.GAME_URL || 'http://localhost:5173';
 const OUTPUT_DIR = process.env.OUTPUT_DIR || path.join(process.cwd(), 'output');
 const BUNDLES_DIR = process.env.BUNDLES_DIR || path.join(__dirname, '../../bundles');
+const BFF_BASE_URL = process.env.BFF_BASE_URL || 'http://localhost:11001';
+const BFF_SERVICE_TOKEN = process.env.BFF_SERVICE_TOKEN;
+const MAX_CACHE_SIZE = parseInt(process.env.MAX_CACHE_SIZE || '10737418240'); // 10GB default
+
+// Initialize OSS Client (for downloading bundles)
+const ossClient = createOSSClient({
+    bffBaseUrl: BFF_BASE_URL,
+    serviceToken: BFF_SERVICE_TOKEN,
+    timeout: 30000,
+});
+
+// Initialize Bundle Manager
+const bundleManager = createBundleManager({
+    bundlesDir: BUNDLES_DIR,
+    maxCacheSize: MAX_CACHE_SIZE,
+    ossClient,
+});
 
 /**
- * GET /bundles
+ * GET /api/bundles
  * List available game bundles
- * This route must be registered BEFORE the static middleware to handle /bundles requests
  */
-app.get('/bundles', (req, res) => {
-    console.log('[GET /bundles] Request received');
+app.get('/api/bundles', (req, res) => {
+    console.log('[GET /api/bundles] Request received');
     try {
-        // Ensure bundles directory exists
-        if (!fs.existsSync(BUNDLES_DIR)) {
-            return res.json({ bundles: [], count: 0 });
-        }
+        const bundles = bundleManager.listBundles().map(info => ({
+            bundleId: info.bundleId,
+            status: info.status,
+            size: info.size,
+            cachedAt: info.cachedAt,
+            lastAccessedAt: info.lastAccessedAt,
+            url: info.status === 'ready'
+                ? `http://localhost:${PORT}/bundles/${info.bundleId}/`
+                : undefined,
+            ready: info.status === 'ready',
+            progress: info.progress,
+            error: info.error,
+        }));
 
-        // List directories in bundles folder
-        const entries = fs.readdirSync(BUNDLES_DIR, { withFileTypes: true });
-        const bundles = entries
-            .filter(entry => entry.isDirectory())
-            .map(entry => {
-                const bundlePath = path.join(BUNDLES_DIR, entry.name);
-                const indexPath = path.join(bundlePath, 'index.html');
-                const hasIndex = fs.existsSync(indexPath);
-                
-                return {
-                    bundleId: entry.name,
-                    path: bundlePath,
-                    url: `http://localhost:${PORT}/bundles/${entry.name}/`,
-                    ready: hasIndex,
-                };
-            });
+        const cacheStats = bundleManager.getCacheStats();
 
-        console.log('[GET /bundles] Found bundles:', bundles.length);
+        console.log('[GET /api/bundles] Found bundles:', bundles.length);
         res.json({
             bundles,
             count: bundles.length,
-            bundlesDir: BUNDLES_DIR,
+            cache: cacheStats,
         });
     } catch (error) {
-        console.error('[GET /bundles] Error listing bundles:', error);
+        console.error('[GET /api/bundles] Error listing bundles:', error);
         res.status(500).json({ error: 'Failed to list bundles' });
     }
 });
 
-// Serve static game bundles (AFTER API route to allow /bundles/<bundleId>/ paths)
+/**
+ * GET /api/bundles/stats
+ * Get cache and download statistics
+ */
+app.get('/api/bundles/stats', (req, res) => {
+    console.log('[GET /api/bundles/stats] Request received');
+    try {
+        const cacheStats = bundleManager.getCacheStats();
+        const downloadStats = bundleManager.getDownloadStats();
+
+        res.json({
+            cache: cacheStats,
+            downloads: downloadStats,
+        });
+    } catch (error) {
+        console.error('[GET /api/bundles/stats] Error getting stats:', error);
+        res.status(500).json({ error: 'Failed to get stats' });
+    }
+});
+
+/**
+ * POST /api/bundles/preload
+ * Preload a bundle (async download)
+ */
+app.post('/api/bundles/preload', async (req, res) => {
+    console.log('[POST /api/bundles/preload] Request received');
+    try {
+        const { bundleId, bundleUrl } = req.body;
+
+        if (!bundleId) {
+            return res.status(400).json({ error: 'bundleId is required' });
+        }
+
+        if (!bundleUrl) {
+            return res.status(400).json({ error: 'bundleUrl is required' });
+        }
+
+        // Check if already cached
+        if (bundleManager.isCached(bundleId)) {
+            return res.json({
+                bundleId,
+                status: 'ready',
+                message: 'Bundle already cached',
+            });
+        }
+
+        // Start download in background (non-blocking)
+        bundleManager.ensureBundle(bundleId, bundleUrl).catch(error => {
+            console.error(`[POST /api/bundles/preload] Failed to download ${bundleId}:`, error);
+        });
+
+        res.json({
+            bundleId,
+            status: 'downloading',
+            message: 'Bundle download started',
+        });
+    } catch (error) {
+        console.error('[POST /api/bundles/preload] Error:', error);
+        res.status(500).json({ error: 'Failed to start bundle download' });
+    }
+});
+
+/**
+ * GET /api/bundles/:bundleId
+ * Get specific bundle info
+ */
+app.get('/api/bundles/:bundleId', (req, res) => {
+    const { bundleId } = req.params;
+    console.log(`[GET /api/bundles/${bundleId}] Request received`);
+
+    try {
+        const info = bundleManager.getBundleInfo(bundleId);
+
+        if (!info) {
+            return res.status(404).json({ error: 'Bundle not found' });
+        }
+
+        res.json({
+            bundleId: info.bundleId,
+            status: info.status,
+            size: info.size,
+            cachedAt: info.cachedAt,
+            lastAccessedAt: info.lastAccessedAt,
+            url: info.status === 'ready'
+                ? `http://localhost:${PORT}/bundles/${info.bundleId}/`
+                : undefined,
+            ready: info.status === 'ready',
+            progress: info.progress,
+            error: info.error,
+        });
+    } catch (error) {
+        console.error(`[GET /api/bundles/${bundleId}] Error:`, error);
+        res.status(500).json({ error: 'Failed to get bundle info' });
+    }
+});
+
+/**
+ * DELETE /api/bundles/:bundleId
+ * Remove bundle from cache
+ */
+app.delete('/api/bundles/:bundleId', (req, res) => {
+    const { bundleId } = req.params;
+    console.log(`[DELETE /api/bundles/${bundleId}] Request received`);
+
+    try {
+        const info = bundleManager.getBundleInfo(bundleId);
+
+        if (!info) {
+            return res.status(404).json({ error: 'Bundle not found' });
+        }
+
+        bundleManager.removeBundle(bundleId);
+
+        res.json({
+            bundleId,
+            message: 'Bundle removed from cache',
+        });
+    } catch (error) {
+        console.error(`[DELETE /api/bundles/${bundleId}] Error:`, error);
+        res.status(500).json({ error: 'Failed to remove bundle' });
+    }
+});
+
+// Serve static game bundles at /bundles/<bundleId>/
+// API routes are at /api/bundles/* to avoid conflicts
 app.use('/bundles', express.static(BUNDLES_DIR, {
     index: 'index.html',
     extensions: ['html']
@@ -91,37 +231,37 @@ app.get('/debug/chrome', async (req, res) => {
         executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium',
         tests: {}
     };
-    
+
     try {
         // Test 1: Check if chromium exists
-        const version = execSync(`${results.executablePath} --version`, { 
+        const version = execSync(`${results.executablePath} --version`, {
             encoding: 'utf8',
-            timeout: 5000 
+            timeout: 5000
         });
         results.tests.version = { ok: true, output: version.trim() };
     } catch (e: any) {
-        results.tests.version = { 
-            ok: false, 
+        results.tests.version = {
+            ok: false,
             error: e.message,
-            stderr: e.stderr?.toString() 
+            stderr: e.stderr?.toString()
         };
     }
-    
+
     try {
         // Test 2: Check library dependencies
-        const ldd = execSync(`ldd ${results.executablePath}`, { 
+        const ldd = execSync(`ldd ${results.executablePath}`, {
             encoding: 'utf8',
-            timeout: 5000 
+            timeout: 5000
         });
         results.tests.dependencies = { ok: true, summary: 'All libraries found' };
     } catch (e: any) {
-        results.tests.dependencies = { 
-            ok: false, 
+        results.tests.dependencies = {
+            ok: false,
             error: e.message,
-            stderr: e.stderr?.toString() 
+            stderr: e.stderr?.toString()
         };
     }
-    
+
     try {
         // Test 3: Check if Chinese fonts are available
         const fonts = execSync(`fc-list :lang=zh-cn`, {
@@ -140,28 +280,45 @@ app.get('/debug/chrome', async (req, res) => {
             error: 'fontconfig not available or no Chinese fonts found'
         };
     }
-    
+
     res.json(results);
 });
 
 /**
  * Resolve game URL from manifest bundleId or config
+ * Now supports dynamic bundle downloading
  */
-function resolveGameUrl(manifest: ReplayManifestV1, configGameUrl?: string): string {
+async function resolveGameUrl(
+    manifest: { bundleId?: string; bundleUrl?: string; [key: string]: unknown },
+    config?: { gameUrl?: string; bundleUrl?: string }
+): Promise<string> {
     // 1. Explicit gameUrl in config takes precedence
-    if (configGameUrl) {
-        return configGameUrl;
+    if (config?.gameUrl) {
+        return config.gameUrl;
     }
-    
+
     // 2. Use bundleId from manifest to serve from local bundles
     if (manifest.bundleId) {
-        const bundlePath = path.join(BUNDLES_DIR, manifest.bundleId);
-        if (!fs.existsSync(bundlePath)) {
-            throw new Error(`Bundle not found: ${manifest.bundleId}`);
+        // Get bundleUrl from manifest or config
+        const bundleUrl = manifest.bundleUrl || config?.bundleUrl;
+
+        // Ensure bundle is available (download if needed)
+        try {
+            await bundleManager.ensureBundle(manifest.bundleId, bundleUrl);
+        } catch (error) {
+            if (error instanceof BundleManagerError && error.code === 'BUNDLE_URL_REQUIRED') {
+                // Bundle not cached and no URL provided - check if it exists locally
+                if (!bundleManager.isCached(manifest.bundleId)) {
+                    throw new Error(`Bundle ${manifest.bundleId} not found and no bundleUrl provided`);
+                }
+            } else {
+                throw error;
+            }
         }
+
         return `http://localhost:${PORT}/bundles/${manifest.bundleId}/`;
     }
-    
+
     // 3. Fall back to default GAME_URL
     return GAME_URL;
 }
@@ -175,6 +332,7 @@ interface RenderJob {
     error: string | null;
     createdAt: Date;
     completedAt: Date | null;
+    bundleId?: string;
 }
 
 const jobs = new Map<string, RenderJob>();
@@ -192,7 +350,13 @@ app.post('/render', async (req, res) => {
         const { manifest, manifestUrl, config } = req.body;
 
         // Get manifest from body or URL
-        let replayManifest: ReplayManifestV1;
+        let replayManifest: {
+            schema: string;
+            bundleId?: string;
+            bundleUrl?: string;
+            gameId: string;
+            [key: string]: unknown;
+        };
 
         if (manifest) {
             replayManifest = manifest;
@@ -208,10 +372,17 @@ app.post('/render', async (req, res) => {
             return res.status(400).json({ error: 'Either manifest or manifestUrl is required' });
         }
 
-        // Validate manifest
-        if (replayManifest.schema !== 'lifeRestart.replay.v1') {
-            console.error('[POST /render] Invalid manifest schema:', replayManifest.schema);
-            return res.status(400).json({ error: 'Invalid manifest schema' });
+        // Validate manifest - basic structure only (schema-agnostic)
+        console.log('[POST /render] Manifest schema:', replayManifest.schema);
+        
+        if (!replayManifest.schema || typeof replayManifest.schema !== 'string') {
+            console.error('[POST /render] Missing or invalid schema field');
+            return res.status(400).json({ error: 'Manifest must have a schema field' });
+        }
+
+        if (!replayManifest.gameId || typeof replayManifest.gameId !== 'string') {
+            console.error('[POST /render] Missing or invalid gameId field');
+            return res.status(400).json({ error: 'Manifest must have a gameId field' });
         }
 
         // Create job
@@ -226,20 +397,27 @@ app.post('/render', async (req, res) => {
             error: null,
             createdAt: new Date(),
             completedAt: null,
+            bundleId: replayManifest.bundleId,
         };
 
         jobs.set(jobId, job);
 
-        // Resolve game URL from bundleId or config
+        // Resolve game URL from bundleId or config (async - may download bundle)
         let gameUrl: string;
         try {
-            gameUrl = resolveGameUrl(replayManifest, config?.gameUrl);
+            gameUrl = await resolveGameUrl(replayManifest, config);
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.error('[POST /render] Failed to resolve game URL:', errorMessage);
+            jobs.delete(jobId);
             return res.status(400).json({ error: errorMessage });
         }
 
+        // Mark bundle as in use during rendering
+        if (replayManifest.bundleId) {
+            bundleManager.markInUse(replayManifest.bundleId);
+        }
+
         // Start rendering in background
         processJob(job, replayManifest, {
             gameUrl,
@@ -340,18 +518,15 @@ app.get('/download/:jobId', (req, res) => {
  * Health check endpoint
  */
 app.get('/health', (req, res) => {
-    // Count available bundles
-    let bundleCount = 0;
-    if (fs.existsSync(BUNDLES_DIR)) {
-        const entries = fs.readdirSync(BUNDLES_DIR, { withFileTypes: true });
-        bundleCount = entries.filter(e => e.isDirectory()).length;
-    }
+    const cacheStats = bundleManager.getCacheStats();
 
     res.json({
         status: 'ok',
         gameUrl: GAME_URL,
         bundlesDir: BUNDLES_DIR,
-        bundleCount,
+        bundleCount: cacheStats.bundleCount,
+        cache: cacheStats,
+        bffBaseUrl: BFF_BASE_URL,
     });
 });
 
@@ -360,7 +535,7 @@ app.get('/health', (req, res) => {
  */
 async function processJob(
     job: RenderJob,
-    manifest: ReplayManifestV1,
+    manifest: { schema: string; gameId: string; [key: string]: unknown },
     config: {
         gameUrl: string;
         outputPath: string;
@@ -395,6 +570,11 @@ async function processJob(
     }
 
     job.completedAt = new Date();
+
+    // Mark bundle as no longer in use
+    if (job.bundleId) {
+        bundleManager.markNotInUse(job.bundleId);
+    }
 }
 
 // Start server
@@ -403,5 +583,6 @@ app.listen(PORT, () => {
     console.log(`📺 Default Game URL: ${GAME_URL}`);
     console.log(`📦 Bundles directory: ${BUNDLES_DIR}`);
     console.log(`📁 Output directory: ${OUTPUT_DIR}`);
+    console.log(`🔗 BFF Base URL: ${BFF_BASE_URL}`);
+    console.log(`💾 Max cache size: ${(MAX_CACHE_SIZE / 1024 / 1024 / 1024).toFixed(2)} GB`);
 });
-