@agent-foundry/replay-server 1.0.0

package/scripts/build-bundle.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Build a game and copy to bundles directory
+# Usage: ./build-bundle.sh game-life-restart
+#
+# This script:
+# 1. Builds the specified game from repo/
+# 2. Copies the dist/ output to bundles/<game-name>/
+
+set -e
+
+GAME_NAME=$1
+
+if [ -z "$GAME_NAME" ]; then
+    echo "Usage: $0 <game-name>"
+    echo "Example: $0 game-life-restart"
+    exit 1
+fi
+
+# Get the repo root (3 levels up from this script)
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+REPO_ROOT=$(cd "$SCRIPT_DIR/../../.." && pwd)
+GAME_DIR="$REPO_ROOT/repo/$GAME_NAME"
+BUNDLES_DIR="$SCRIPT_DIR/../bundles"
+
+# Verify game exists
+if [ ! -d "$GAME_DIR" ]; then
+    echo "Error: Game directory not found: $GAME_DIR"
+    exit 1
+fi
+
+echo "📦 Building $GAME_NAME..."
+echo "   Game directory: $GAME_DIR"
+echo "   Bundles directory: $BUNDLES_DIR"
+
+# Build the game with base path for bundle serving
+BASE_PATH="/bundles/$GAME_NAME/"
+echo "📦 Building with base path: $BASE_PATH"
+cd "$GAME_DIR"
+pnpm install
+VITE_BASE_PATH="$BASE_PATH" pnpm build
+
+# Create bundle directory
+mkdir -p "$BUNDLES_DIR/$GAME_NAME"
+
+# Copy build output
+echo "📋 Copying build output to bundles..."
+cp -r dist/* "$BUNDLES_DIR/$GAME_NAME/"
+
+echo "✅ Bundle created: $BUNDLES_DIR/$GAME_NAME"
+echo ""
+echo "To use this bundle, set bundleId in your manifest:"
+echo '  { "bundleId": "'$GAME_NAME'" }'

package/scripts/deploy-aliyun.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+# Deploy replay-server to Aliyun Container Registry (ACR)
+#
+# Prerequisites:
+#   1. Docker installed and running
+#   2. Logged into ACR: docker login registry.cn-beijing.aliyuncs.com
+#
+# Usage:
+#   ./deploy-aliyun.sh
+#   ./deploy-aliyun.sh <custom-tag>
+#
+# Environment variables (optional):
+#   ACR_REGISTRY  - ACR registry URL (default: registry.cn-beijing.aliyuncs.com)
+#   ACR_NAMESPACE - Your ACR namespace (required)
+#   IMAGE_NAME    - Image name (default: replay-server)
+
+set -e
+
+# Configuration
+ACR_REGISTRY="${ACR_REGISTRY:-registry.cn-beijing.aliyuncs.com}"
+ACR_NAMESPACE="${ACR_NAMESPACE:-}"
+IMAGE_NAME="${IMAGE_NAME:-replay-server}"
+VERSION="${1:-$(date +%Y%m%d-%H%M%S)}"
+
+# Validate namespace
+if [ -z "$ACR_NAMESPACE" ]; then
+    echo "Error: ACR_NAMESPACE environment variable is required"
+    echo ""
+    echo "Usage:"
+    echo "  ACR_NAMESPACE=your-namespace ./deploy-aliyun.sh"
+    echo ""
+    echo "Or set it in your environment:"
+    echo "  export ACR_NAMESPACE=your-namespace"
+    exit 1
+fi
+
+# Get repo root
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+REPO_ROOT=$(cd "$SCRIPT_DIR/../../.." && pwd)
+
+echo "🚀 Deploying replay-server to Aliyun ACR"
+echo "   Registry: $ACR_REGISTRY"
+echo "   Namespace: $ACR_NAMESPACE"
+echo "   Image: $IMAGE_NAME"
+echo "   Version: $VERSION"
+echo ""
+
+# Build from project root
+cd "$REPO_ROOT"
+
+FULL_IMAGE="${ACR_REGISTRY}/${ACR_NAMESPACE}/${IMAGE_NAME}"
+
+echo "📦 Building Docker image..."
+docker build \
+    -f packages/replay-server/Dockerfile \
+    -t "${FULL_IMAGE}:${VERSION}" \
+    -t "${FULL_IMAGE}:latest" \
+    .
+
+echo ""
+echo "📤 Pushing to ACR..."
+docker push "${FULL_IMAGE}:${VERSION}"
+docker push "${FULL_IMAGE}:latest"
+
+echo ""
+echo "✅ Deployment complete!"
+echo ""
+echo "Image URLs:"
+echo "  ${FULL_IMAGE}:${VERSION}"
+echo "  ${FULL_IMAGE}:latest"
+echo ""
+echo "Next steps:"
+echo "  1. Go to Aliyun Function Compute console"
+echo "  2. Create/update function with image: ${FULL_IMAGE}:${VERSION}"
+echo "  3. Set environment variables:"
+echo "     - PORT=9000"
+echo "     - OUTPUT_DIR=/tmp/output"
+echo "  4. Configure function settings:"
+echo "     - Memory: 4096 MB"
+echo "     - Timeout: 600 seconds"
+echo "     - Instance Concurrency: 1"

package/src/cli/render.ts

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+/**
+ * CLI tool for offline video rendering
+ * 
+ * Usage:
+ *   npx tsx src/cli/render.ts --manifest ./replay.json --output ./output.mp4
+ *   npx tsx src/cli/render.ts --manifest-url https://... --game-url http://localhost:5173
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { PuppeteerRenderer, RenderProgress } from '../renderer/PuppeteerRenderer.js';
+import type { ReplayManifestV1 } from '@agent-foundry/replay';
+
+interface CliArgs {
+    manifest?: string;
+    manifestUrl?: string;
+    output: string;
+    gameUrl: string;
+    width: number;
+    height: number;
+    fps: number;
+    secondsPerAge: number;
+    keepTemp: boolean;
+    useHardwareAcceleration: boolean;
+    help: boolean;
+}
+
+function parseArgs(): CliArgs {
+    const args = process.argv.slice(2);
+    const result: CliArgs = {
+        output: './output.mp4',
+        gameUrl: 'http://localhost:5173',
+        width: 720,
+        height: 1280,
+        fps: 16,
+        secondsPerAge: 1.0,
+        keepTemp: false,
+        useHardwareAcceleration: false,
+        help: false,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const next = args[i + 1];
+
+        switch (arg) {
+            case '--manifest':
+            case '-m':
+                result.manifest = next;
+                i++;
+                break;
+            case '--manifest-url':
+                result.manifestUrl = next;
+                i++;
+                break;
+            case '--output':
+            case '-o':
+                result.output = next;
+                i++;
+                break;
+            case '--game-url':
+            case '-g':
+                result.gameUrl = next;
+                i++;
+                break;
+            case '--width':
+                result.width = parseInt(next, 10);
+                i++;
+                break;
+            case '--height':
+                result.height = parseInt(next, 10);
+                i++;
+                break;
+            case '--fps':
+                result.fps = parseInt(next, 10);
+                i++;
+                break;
+            case '--seconds-per-age':
+                result.secondsPerAge = parseFloat(next);
+                i++;
+                break;
+            case '--keep-temp':
+                result.keepTemp = true;
+                break;
+            case '--use-hardware-acceleration':
+            case '--nvenc':
+                result.useHardwareAcceleration = true;
+                break;
+            case '--help':
+            case '-h':
+                result.help = true;
+                break;
+        }
+    }
+
+    return result;
+}
+
+function printHelp(): void {
+    console.log(`
+🎬 LifeRestart Replay Renderer CLI
+
+Usage:
+  npx tsx src/cli/render.ts [options]
+
+Options:
+  -m, --manifest <path>     Path to replay manifest JSON file
+  --manifest-url <url>      URL to fetch replay manifest from
+  -o, --output <path>       Output video path (default: ./output.mp4)
+  -g, --game-url <url>      Game URL (default: http://localhost:5173)
+  --width <px>              Video width (default: 720)
+  --height <px>             Video height (default: 1280)
+  --fps <n>                 Frames per second (default: 16)
+  --seconds-per-age <n>     Seconds to display each age (default: 1.0)
+  --use-hardware-acceleration  Enable NVENC hardware acceleration (default: CPU encoding)
+  --nvenc                   Alias for --use-hardware-acceleration
+  --keep-temp               Keep temporary screenshot files (deprecated)
+  -h, --help                Show this help message
+
+Examples:
+  # Render from local manifest file
+  npx tsx src/cli/render.ts -m ./replay.json -o ./video.mp4
+
+  # Render from URL
+  npx tsx src/cli/render.ts --manifest-url https://example.com/replay.json
+
+  # Custom video settings
+  npx tsx src/cli/render.ts -m ./replay.json --width 720 --height 1280 --fps 60
+`);
+}
+
+async function loadManifest(args: CliArgs): Promise<ReplayManifestV1> {
+    if (args.manifest) {
+        const manifestPath = path.resolve(args.manifest);
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Manifest file not found: ${manifestPath}`);
+        }
+        const content = await fs.promises.readFile(manifestPath, 'utf-8');
+        return JSON.parse(content);
+    }
+
+    if (args.manifestUrl) {
+        const response = await fetch(args.manifestUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch manifest: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+
+    throw new Error('Either --manifest or --manifest-url is required');
+}
+
+function formatProgress(progress: RenderProgress): string {
+    const percent = progress.total > 0
+        ? Math.round((progress.current / progress.total) * 100)
+        : 0;
+
+    const bar = '█'.repeat(Math.floor(percent / 5)) + '░'.repeat(20 - Math.floor(percent / 5));
+
+    return `[${bar}] ${percent}% - ${progress.message}`;
+}
+
+async function main(): Promise<void> {
+    const args = parseArgs();
+
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+
+    if (!args.manifest && !args.manifestUrl) {
+        console.error('Error: Either --manifest or --manifest-url is required');
+        console.error('Run with --help for usage information');
+        process.exit(1);
+    }
+
+    console.log('🎬 LifeRestart Replay Renderer');
+    console.log('━'.repeat(50));
+
+    try {
+        // Load manifest
+        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}`);
+
+        // Estimate duration
+        const estimatedDuration = manifest.timeline.length * args.secondsPerAge;
+        console.log(`   Estimated video duration: ${estimatedDuration}s`);
+        console.log('');
+
+        // Create output directory
+        const outputDir = path.dirname(path.resolve(args.output));
+        await fs.promises.mkdir(outputDir, { recursive: true });
+
+        // Start rendering
+        console.log('🚀 Starting render...');
+        console.log(`   Game URL: ${args.gameUrl}`);
+        console.log(`   Output: ${args.output}`);
+        console.log(`   Resolution: ${args.width}x${args.height} @ ${args.fps}fps`);
+        console.log(`   Encoder: ${args.useHardwareAcceleration ? 'h264_nvenc (Hardware)' : 'libx264 (CPU)'}`);
+        console.log('');
+
+        const renderer = new PuppeteerRenderer();
+
+        let lastLine = '';
+        const result = await renderer.render(manifest, {
+            gameUrl: args.gameUrl,
+            outputPath: path.resolve(args.output),
+            width: args.width,
+            height: args.height,
+            fps: args.fps,
+            secondsPerAge: args.secondsPerAge,
+            useHardwareAcceleration: args.useHardwareAcceleration,
+            keepTempFiles: args.keepTemp,
+            onProgress: (progress) => {
+                const line = formatProgress(progress);
+                if (line !== lastLine) {
+                    process.stdout.write(`\r${line}`);
+                    lastLine = line;
+                }
+            },
+        });
+
+        console.log('\n');
+
+        if (result.success) {
+            console.log('✅ Render completed successfully!');
+            console.log(`   Output: ${result.outputPath}`);
+            console.log(`   Duration: ${result.duration?.toFixed(1)}s`);
+        } else {
+            console.error('❌ Render failed:', result.error);
+            process.exit(1);
+        }
+    } catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+
+main();

package/src/index.ts

@@ -0,0 +1,2 @@
+// Main exports
+export * from './renderer';