@agent-foundry/replay-server 1.0.0

package/src/server/index.ts

@@ -0,0 +1,407 @@
+/**
+ * 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
+ */
+
+import express, { type Express } from 'express';
+import cors from 'cors';
+import { v4 as uuidv4 } from 'uuid';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { execSync } from 'child_process';
+import { PuppeteerRenderer, RenderProgress } from '../renderer/PuppeteerRenderer.js';
+import type { ReplayManifestV1 } from '@agent-foundry/replay';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const app: Express = express();
+app.use(cors());
+app.use(express.json({ limit: '10mb' }));
+
+// Configuration
+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');
+
+/**
+ * GET /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');
+    try {
+        // Ensure bundles directory exists
+        if (!fs.existsSync(BUNDLES_DIR)) {
+            return res.json({ bundles: [], count: 0 });
+        }
+
+        // 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,
+                };
+            });
+
+        console.log('[GET /bundles] Found bundles:', bundles.length);
+        res.json({
+            bundles,
+            count: bundles.length,
+            bundlesDir: BUNDLES_DIR,
+        });
+    } catch (error) {
+        console.error('[GET /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)
+app.use('/bundles', express.static(BUNDLES_DIR, {
+    index: 'index.html',
+    extensions: ['html']
+}));
+
+/**
+ * GET /debug/chrome
+ * Debug endpoint to verify Chromium installation
+ */
+app.get('/debug/chrome', async (req, res) => {
+    const results: any = {
+        executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium',
+        tests: {}
+    };
+    
+    try {
+        // Test 1: Check if chromium exists
+        const version = execSync(`${results.executablePath} --version`, { 
+            encoding: 'utf8',
+            timeout: 5000 
+        });
+        results.tests.version = { ok: true, output: version.trim() };
+    } catch (e: any) {
+        results.tests.version = { 
+            ok: false, 
+            error: e.message,
+            stderr: e.stderr?.toString() 
+        };
+    }
+    
+    try {
+        // Test 2: Check library dependencies
+        const ldd = execSync(`ldd ${results.executablePath}`, { 
+            encoding: 'utf8',
+            timeout: 5000 
+        });
+        results.tests.dependencies = { ok: true, summary: 'All libraries found' };
+    } catch (e: any) {
+        results.tests.dependencies = { 
+            ok: false, 
+            error: e.message,
+            stderr: e.stderr?.toString() 
+        };
+    }
+    
+    try {
+        // Test 3: Check if Chinese fonts are available
+        const fonts = execSync(`fc-list :lang=zh-cn`, {
+            encoding: 'utf8',
+            timeout: 5000
+        });
+        const fontLines = fonts.split('\n').filter(l => l.trim());
+        results.tests.chineseFonts = {
+            ok: fontLines.length > 0,
+            count: fontLines.length,
+            sample: fontLines.slice(0, 3)
+        };
+    } catch (e: any) {
+        results.tests.chineseFonts = {
+            ok: false,
+            error: 'fontconfig not available or no Chinese fonts found'
+        };
+    }
+    
+    res.json(results);
+});
+
+/**
+ * Resolve game URL from manifest bundleId or config
+ */
+function resolveGameUrl(manifest: ReplayManifestV1, configGameUrl?: string): string {
+    // 1. Explicit gameUrl in config takes precedence
+    if (configGameUrl) {
+        return configGameUrl;
+    }
+    
+    // 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}`);
+        }
+        return `http://localhost:${PORT}/bundles/${manifest.bundleId}/`;
+    }
+    
+    // 3. Fall back to default GAME_URL
+    return GAME_URL;
+}
+
+// Job storage (in-memory for now)
+interface RenderJob {
+    id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    progress: RenderProgress | null;
+    outputPath: string | null;
+    error: string | null;
+    createdAt: Date;
+    completedAt: Date | null;
+}
+
+const jobs = new Map<string, RenderJob>();
+
+// Ensure output directory exists
+fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+
+/**
+ * POST /render
+ * Start a new render job
+ */
+app.post('/render', async (req, res) => {
+    console.log('[POST /render] Request received');
+    try {
+        const { manifest, manifestUrl, config } = req.body;
+
+        // Get manifest from body or URL
+        let replayManifest: ReplayManifestV1;
+
+        if (manifest) {
+            replayManifest = manifest;
+        } else if (manifestUrl) {
+            const response = await fetch(manifestUrl);
+            if (!response.ok) {
+                console.error('[POST /render] Failed to fetch manifest from URL:', manifestUrl);
+                return res.status(400).json({ error: 'Failed to fetch manifest from URL' });
+            }
+            replayManifest = await response.json();
+        } else {
+            console.error('[POST /render] Missing required parameter: manifest or manifestUrl');
+            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' });
+        }
+
+        // Create job
+        const jobId = uuidv4();
+        const outputPath = path.join(OUTPUT_DIR, `${jobId}.mp4`);
+
+        const job: RenderJob = {
+            id: jobId,
+            status: 'pending',
+            progress: null,
+            outputPath: null,
+            error: null,
+            createdAt: new Date(),
+            completedAt: null,
+        };
+
+        jobs.set(jobId, job);
+
+        // Resolve game URL from bundleId or config
+        let gameUrl: string;
+        try {
+            gameUrl = resolveGameUrl(replayManifest, config?.gameUrl);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('[POST /render] Failed to resolve game URL:', errorMessage);
+            return res.status(400).json({ error: errorMessage });
+        }
+
+        // Start rendering in background
+        processJob(job, replayManifest, {
+            gameUrl,
+            outputPath,
+            width: config?.width,
+            height: config?.height,
+            fps: config?.fps,
+            secondsPerAge: config?.secondsPerAge,
+        });
+
+        console.log('[POST /render] Render job started successfully, jobId:', jobId);
+        console.log('[POST /render] Using game URL:', gameUrl);
+        res.json({
+            jobId,
+            status: job.status,
+            message: 'Render job started',
+        });
+    } catch (error) {
+        console.error('[POST /render] Error starting render job:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /jobs
+ * List all jobs
+ */
+app.get('/jobs', (req, res) => {
+    console.log('[GET /jobs] Request received');
+    try {
+        const jobList = Array.from(jobs.values()).map(job => ({
+            jobId: job.id,
+            status: job.status,
+            progress: job.progress,
+            error: job.error,
+            createdAt: job.createdAt,
+            completedAt: job.completedAt,
+        }));
+
+        console.log('[GET /jobs] Returning job list, count:', jobList.length);
+        res.json({
+            jobs: jobList,
+            count: jobList.length,
+        });
+    } catch (error) {
+        console.error('[GET /jobs] Error listing jobs:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /status/:jobId
+ * Get job status
+ */
+app.get('/status/:jobId', (req, res) => {
+    const { jobId } = req.params;
+    const job = jobs.get(jobId);
+
+    if (!job) {
+        return res.status(404).json({ error: 'Job not found' });
+    }
+
+    res.json({
+        jobId: job.id,
+        status: job.status,
+        progress: job.progress,
+        error: job.error,
+        createdAt: job.createdAt,
+        completedAt: job.completedAt,
+    });
+});
+
+/**
+ * GET /download/:jobId
+ * Download completed video
+ */
+app.get('/download/:jobId', (req, res) => {
+    const { jobId } = req.params;
+    const job = jobs.get(jobId);
+
+    if (!job) {
+        return res.status(404).json({ error: 'Job not found' });
+    }
+
+    if (job.status !== 'completed' || !job.outputPath) {
+        return res.status(400).json({ error: 'Job not completed' });
+    }
+
+    if (!fs.existsSync(job.outputPath)) {
+        return res.status(404).json({ error: 'Video file not found' });
+    }
+
+    res.download(job.outputPath, `replay-${jobId}.mp4`);
+});
+
+/**
+ * GET /health
+ * 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;
+    }
+
+    res.json({
+        status: 'ok',
+        gameUrl: GAME_URL,
+        bundlesDir: BUNDLES_DIR,
+        bundleCount,
+    });
+});
+
+/**
+ * Process a render job
+ */
+async function processJob(
+    job: RenderJob,
+    manifest: ReplayManifestV1,
+    config: {
+        gameUrl: string;
+        outputPath: string;
+        width?: number;
+        height?: number;
+        fps?: number;
+        secondsPerAge?: number;
+    }
+): Promise<void> {
+    job.status = 'processing';
+
+    const renderer = new PuppeteerRenderer();
+
+    try {
+        const result = await renderer.render(manifest, {
+            ...config,
+            onProgress: (progress) => {
+                job.progress = progress;
+            },
+        });
+
+        if (result.success) {
+            job.status = 'completed';
+            job.outputPath = result.outputPath || null;
+        } else {
+            job.status = 'failed';
+            job.error = result.error || 'Unknown error';
+        }
+    } catch (error) {
+        job.status = 'failed';
+        job.error = error instanceof Error ? error.message : String(error);
+    }
+
+    job.completedAt = new Date();
+}
+
+// Start server
+app.listen(PORT, () => {
+    console.log(`🎬 Replay Render Server running on http://localhost:${PORT}`);
+    console.log(`📺 Default Game URL: ${GAME_URL}`);
+    console.log(`📦 Bundles directory: ${BUNDLES_DIR}`);
+    console.log(`📁 Output directory: ${OUTPUT_DIR}`);
+});
+

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "lib": [
+            "ES2022",
+            "DOM"
+        ],
+        "types": [
+            "node"
+        ],
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "allowImportingTsExtensions": false,
+        "noEmit": false
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}