@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/esm/build-cloud/BuildOrchestration.js

@@ -0,0 +1,1129 @@
+/**
+ * @file BuildOrchestration.ts
+ * @description Build Orchestration system for managing cloud builds
+ * PRO-1.7.4: Build Orchestration
+ *
+ * Features:
+ * - Build Queue Manager (Kubernetes-based job scheduler)
+ * - Priority queues (paid vs free tier)
+ * - Concurrent build limits
+ * - Auto-scaling workers
+ * - Spot instance support
+ * - Build Agent Pool management
+ * - Artifact Storage (S3/MinIO)
+ * - Build Notifications (webhooks, email, Slack, Discord)
+ * - Build Analytics
+ */
+class BuildQueueManager {
+    constructor() {
+        this.queues = new Map();
+        this.jobs = new Map();
+        this.jobQueues = new Map(); // queue name -> job IDs
+        this.callbacks = {};
+        // Create default queues
+        this.createDefaultQueues();
+    }
+    createDefaultQueues() {
+        const defaultQueues = [
+            {
+                name: 'free-linux',
+                priority: 'low',
+                maxConcurrent: 2,
+                maxQueueSize: 100,
+                buildTimeout: 1800000, // 30 min
+                supportedEngines: ['unity', 'godot', 'nice2dev'],
+                supportedPlatforms: ['linux', 'webgl', 'web'],
+                isPaidTier: false,
+                rateLimitPerHour: 5,
+            },
+            {
+                name: 'free-windows',
+                priority: 'low',
+                maxConcurrent: 2,
+                maxQueueSize: 100,
+                buildTimeout: 1800000,
+                supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
+                supportedPlatforms: ['windows', 'android'],
+                isPaidTier: false,
+                rateLimitPerHour: 5,
+            },
+            {
+                name: 'pro-priority',
+                priority: 'high',
+                maxConcurrent: 10,
+                maxQueueSize: 500,
+                buildTimeout: 7200000, // 2 hours
+                supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
+                supportedPlatforms: ['*'],
+                isPaidTier: true,
+            },
+            {
+                name: 'enterprise',
+                priority: 'critical',
+                maxConcurrent: 50,
+                maxQueueSize: 1000,
+                buildTimeout: 14400000, // 4 hours
+                supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
+                supportedPlatforms: ['*'],
+                isPaidTier: true,
+            },
+        ];
+        for (const queue of defaultQueues) {
+            this.queues.set(queue.name, queue);
+            this.jobQueues.set(queue.name, []);
+        }
+    }
+    // ─── Queue Management ──────────────────────────────────
+    createQueue(config) {
+        this.queues.set(config.name, config);
+        this.jobQueues.set(config.name, []);
+    }
+    getQueue(name) {
+        return this.queues.get(name);
+    }
+    getQueues() {
+        return Array.from(this.queues.values());
+    }
+    deleteQueue(name) {
+        if (!this.queues.has(name)) {
+            return false;
+        }
+        // Cancel all jobs in queue
+        const queueJobs = this.jobQueues.get(name) ?? [];
+        for (const jobId of queueJobs) {
+            this.cancelJob(jobId);
+        }
+        this.queues.delete(name);
+        this.jobQueues.delete(name);
+        return true;
+    }
+    // ─── Job Management ────────────────────────────────────
+    submitJob(engine, platform, buildConfig, options) {
+        const jobId = this.generateJobId();
+        const priority = options?.priority ?? 'normal';
+        // Find appropriate queue
+        const queueName = this.findQueueForJob(engine, platform, priority);
+        if (!queueName) {
+            throw new Error(`No available queue for ${engine}/${platform}`);
+        }
+        const queue = this.queues.get(queueName);
+        const queueJobs = this.jobQueues.get(queueName);
+        // Check queue limits
+        if (queueJobs.length >= queue.maxQueueSize) {
+            throw new Error(`Queue ${queueName} is full`);
+        }
+        const job = {
+            id: jobId,
+            userId: options?.userId ?? 'anonymous',
+            engine,
+            platform,
+            priority,
+            status: 'queued',
+            queuePosition: queueJobs.length + 1,
+            createdAt: Date.now(),
+            buildConfig,
+            retryCount: 0,
+            maxRetries: options?.maxRetries ?? 3,
+            estimatedWaitTime: this.estimateWaitTime(queueName),
+            estimatedBuildTime: this.estimateBuildTime(engine, platform),
+        };
+        this.jobs.set(jobId, job);
+        queueJobs.push(jobId);
+        this.callbacks.onJobQueued?.(job);
+        return job;
+    }
+    findQueueForJob(engine, platform, priority) {
+        for (const [name, queue] of this.queues) {
+            if (!queue.supportedEngines.includes(engine)) {
+                continue;
+            }
+            if (!queue.supportedPlatforms.includes('*') && !queue.supportedPlatforms.includes(platform)) {
+                continue;
+            }
+            if (this.getPriorityLevel(priority) > this.getPriorityLevel(queue.priority)) {
+                continue;
+            }
+            return name;
+        }
+        return null;
+    }
+    getPriorityLevel(priority) {
+        const levels = {
+            low: 0,
+            normal: 1,
+            high: 2,
+            critical: 3,
+        };
+        return levels[priority];
+    }
+    generateJobId() {
+        return `job-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    estimateWaitTime(queueName) {
+        const queue = this.queues.get(queueName);
+        const queueJobs = this.jobQueues.get(queueName);
+        if (!queue || !queueJobs) {
+            return 0;
+        }
+        // Simple estimation: position * average build time / concurrent builds
+        const avgBuildTime = 600000; // 10 minutes average
+        return (queueJobs.length * avgBuildTime) / queue.maxConcurrent;
+    }
+    estimateBuildTime(engine, platform) {
+        // Rough estimates in ms
+        const estimates = {
+            unity: 900000, // 15 minutes
+            godot: 300000, // 5 minutes
+            unreal: 1800000, // 30 minutes
+            nice2dev: 120000, // 2 minutes
+        };
+        return estimates[engine] ?? 600000;
+    }
+    cancelJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job) {
+            return false;
+        }
+        if (job.status === 'completed' || job.status === 'cancelled') {
+            return false;
+        }
+        job.status = 'cancelled';
+        job.completedAt = Date.now();
+        // Remove from queue
+        for (const [queueName, queueJobs] of this.jobQueues) {
+            const idx = queueJobs.indexOf(jobId);
+            if (idx !== -1) {
+                queueJobs.splice(idx, 1);
+                this.updateQueuePositions(queueName);
+                break;
+            }
+        }
+        this.callbacks.onJobCancelled?.(job);
+        return true;
+    }
+    updateQueuePositions(queueName) {
+        const queueJobs = this.jobQueues.get(queueName);
+        if (!queueJobs) {
+            return;
+        }
+        for (let i = 0; i < queueJobs.length; i++) {
+            const job = this.jobs.get(queueJobs[i]);
+            if (job && job.status === 'queued') {
+                job.queuePosition = i + 1;
+            }
+        }
+    }
+    getJob(jobId) {
+        return this.jobs.get(jobId);
+    }
+    getJobsByUser(userId) {
+        return Array.from(this.jobs.values()).filter((job) => job.userId === userId);
+    }
+    getJobsByStatus(status) {
+        return Array.from(this.jobs.values()).filter((job) => job.status === status);
+    }
+    // ─── Job Assignment ────────────────────────────────────
+    assignJobToAgent(jobId, agentId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'queued') {
+            return false;
+        }
+        job.status = 'assigned';
+        job.assignedAgentId = agentId;
+        job.startedAt = Date.now();
+        this.callbacks.onJobAssigned?.(job, agentId);
+        return true;
+    }
+    startJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'assigned') {
+            return false;
+        }
+        job.status = 'running';
+        this.callbacks.onJobStarted?.(job);
+        return true;
+    }
+    completeJob(jobId, artifacts) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'running') {
+            return false;
+        }
+        job.status = 'completed';
+        job.completedAt = Date.now();
+        job.artifacts = artifacts;
+        this.callbacks.onJobCompleted?.(job);
+        return true;
+    }
+    failJob(jobId, error) {
+        const job = this.jobs.get(jobId);
+        if (!job) {
+            return false;
+        }
+        job.error = error;
+        // Check if should retry
+        if (job.retryCount < job.maxRetries) {
+            job.retryCount++;
+            job.status = 'queued';
+            job.assignedAgentId = undefined;
+            job.startedAt = undefined;
+            this.callbacks.onJobRetry?.(job);
+        }
+        else {
+            job.status = 'failed';
+            job.completedAt = Date.now();
+            this.callbacks.onJobFailed?.(job, error);
+        }
+        return true;
+    }
+    // ─── Queue Stats ───────────────────────────────────────
+    getQueueStats(queueName) {
+        const queue = this.queues.get(queueName);
+        const queueJobs = this.jobQueues.get(queueName);
+        if (!queue || !queueJobs) {
+            return undefined;
+        }
+        let running = 0;
+        let waiting = 0;
+        for (const jobId of queueJobs) {
+            const job = this.jobs.get(jobId);
+            if (!job) {
+                continue;
+            }
+            if (job.status === 'running') {
+                running++;
+            }
+            else if (job.status === 'queued') {
+                waiting++;
+            }
+        }
+        return {
+            queueName,
+            totalJobs: queueJobs.length,
+            runningJobs: running,
+            waitingJobs: waiting,
+            maxConcurrent: queue.maxConcurrent,
+            maxQueueSize: queue.maxQueueSize,
+            utilizationPercent: (running / queue.maxConcurrent) * 100,
+            estimatedWaitTime: this.estimateWaitTime(queueName),
+        };
+    }
+    getAllQueueStats() {
+        return Array.from(this.queues.keys())
+            .map((name) => this.getQueueStats(name))
+            .filter(Boolean);
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+class BuildAgentPool {
+    constructor() {
+        this.agents = new Map();
+        this.pools = new Map();
+        this.callbacks = {};
+        this.heartbeatInterval = 30000; // 30 seconds
+        this.heartbeatTimeout = 90000; // 90 seconds
+        // Create default pools
+        this.createDefaultPools();
+    }
+    createDefaultPools() {
+        const defaultPools = [
+            {
+                name: 'linux-pool',
+                minAgents: 2,
+                maxAgents: 20,
+                agentTemplate: {
+                    os: 'linux',
+                    supportedEngines: ['unity', 'godot', 'nice2dev'],
+                    supportedPlatforms: ['linux', 'webgl', 'web', 'android'],
+                    cpuCores: 8,
+                    memoryGB: 32,
+                    diskGB: 500,
+                },
+                autoScaling: true,
+                scaleUpThreshold: 5,
+                scaleDownThreshold: 300000, // 5 minutes
+                useSpotInstances: true,
+                spotPercentage: 50,
+            },
+            {
+                name: 'windows-pool',
+                minAgents: 2,
+                maxAgents: 20,
+                agentTemplate: {
+                    os: 'windows',
+                    supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
+                    supportedPlatforms: ['windows', 'android', 'uwp'],
+                    cpuCores: 16,
+                    memoryGB: 64,
+                    diskGB: 1000,
+                },
+                autoScaling: true,
+                scaleUpThreshold: 3,
+                scaleDownThreshold: 300000,
+                useSpotInstances: true,
+                spotPercentage: 30,
+            },
+            {
+                name: 'macos-pool',
+                minAgents: 1,
+                maxAgents: 10,
+                agentTemplate: {
+                    os: 'macos',
+                    supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
+                    supportedPlatforms: ['macos', 'ios', 'tvos'],
+                    cpuCores: 8,
+                    memoryGB: 32,
+                    diskGB: 500,
+                },
+                autoScaling: true,
+                scaleUpThreshold: 2,
+                scaleDownThreshold: 600000, // 10 minutes (more expensive)
+                useSpotInstances: false,
+                spotPercentage: 0,
+            },
+        ];
+        for (const pool of defaultPools) {
+            this.pools.set(pool.name, pool);
+        }
+    }
+    // ─── Pool Management ───────────────────────────────────
+    createPool(config) {
+        this.pools.set(config.name, config);
+    }
+    getPool(name) {
+        return this.pools.get(name);
+    }
+    getPools() {
+        return Array.from(this.pools.values());
+    }
+    deletePool(name) {
+        return this.pools.delete(name);
+    }
+    // ─── Agent Management ──────────────────────────────────
+    registerAgent(agent) {
+        const fullAgent = {
+            ...agent,
+            id: this.generateAgentId(),
+            lastHeartbeat: Date.now(),
+            jobsCompleted: 0,
+            jobsFailed: 0,
+            avgBuildTime: 0,
+        };
+        this.agents.set(fullAgent.id, fullAgent);
+        this.callbacks.onAgentRegistered?.(fullAgent);
+        return fullAgent;
+    }
+    generateAgentId() {
+        return `agent-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    unregisterAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return false;
+        }
+        // If agent has a job, mark it for reassignment
+        if (agent.currentJobId) {
+            this.callbacks.onAgentLostJob?.(agent, agent.currentJobId);
+        }
+        this.agents.delete(agentId);
+        this.callbacks.onAgentUnregistered?.(agent);
+        return true;
+    }
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    getAgents() {
+        return Array.from(this.agents.values());
+    }
+    getAgentsByStatus(status) {
+        return Array.from(this.agents.values()).filter((a) => a.status === status);
+    }
+    getAgentsByOS(os) {
+        return Array.from(this.agents.values()).filter((a) => a.os === os);
+    }
+    getIdleAgents() {
+        return this.getAgentsByStatus('idle');
+    }
+    // ─── Agent Lifecycle ───────────────────────────────────
+    heartbeat(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return false;
+        }
+        agent.lastHeartbeat = Date.now();
+        // Update status if was offline
+        if (agent.status === 'offline') {
+            agent.status = agent.currentJobId ? 'busy' : 'idle';
+            this.callbacks.onAgentOnline?.(agent);
+        }
+        return true;
+    }
+    checkAgentHealth() {
+        const now = Date.now();
+        for (const agent of this.agents.values()) {
+            if (now - agent.lastHeartbeat > this.heartbeatTimeout && agent.status !== 'offline') {
+                agent.status = 'offline';
+                this.callbacks.onAgentOffline?.(agent);
+                // Handle lost job
+                if (agent.currentJobId) {
+                    this.callbacks.onAgentLostJob?.(agent, agent.currentJobId);
+                }
+            }
+        }
+    }
+    assignJob(agentId, jobId) {
+        const agent = this.agents.get(agentId);
+        if (!agent || agent.status !== 'idle') {
+            return false;
+        }
+        agent.status = 'busy';
+        agent.currentJobId = jobId;
+        this.callbacks.onAgentBusy?.(agent, jobId);
+        return true;
+    }
+    completeJob(agentId, success, buildTime) {
+        const agent = this.agents.get(agentId);
+        if (!agent || !agent.currentJobId) {
+            return false;
+        }
+        const jobId = agent.currentJobId;
+        agent.currentJobId = undefined;
+        agent.status = 'idle';
+        if (success) {
+            agent.jobsCompleted++;
+            // Update average build time
+            const totalTime = agent.avgBuildTime * (agent.jobsCompleted - 1) + buildTime;
+            agent.avgBuildTime = totalTime / agent.jobsCompleted;
+        }
+        else {
+            agent.jobsFailed++;
+        }
+        this.callbacks.onAgentIdle?.(agent, jobId);
+        return true;
+    }
+    // ─── Auto-scaling ──────────────────────────────────────
+    evaluateScaling(queueManager) {
+        const decisions = [];
+        for (const [poolName, pool] of this.pools) {
+            if (!pool.autoScaling) {
+                continue;
+            }
+            const poolAgents = Array.from(this.agents.values()).filter((a) => a.os === pool.agentTemplate.os && a.region === (pool.agentTemplate.region ?? 'default'));
+            const idleAgents = poolAgents.filter((a) => a.status === 'idle');
+            poolAgents.filter((a) => a.status === 'busy');
+            // Get queue pressure
+            const queueStats = queueManager.getAllQueueStats();
+            const waitingJobs = queueStats.reduce((sum, s) => sum + s.waitingJobs, 0);
+            // Scale up decision
+            if (waitingJobs >= pool.scaleUpThreshold && poolAgents.length < pool.maxAgents) {
+                const toAdd = Math.min(Math.ceil(waitingJobs / 2), pool.maxAgents - poolAgents.length);
+                decisions.push({
+                    pool: poolName,
+                    action: 'scale_up',
+                    count: toAdd,
+                    reason: `${waitingJobs} jobs waiting, threshold is ${pool.scaleUpThreshold}`,
+                    useSpot: pool.useSpotInstances && Math.random() < pool.spotPercentage / 100,
+                });
+            }
+            // Scale down decision
+            if (idleAgents.length > 0 && poolAgents.length > pool.minAgents) {
+                // Check idle time
+                const now = Date.now();
+                const longIdleAgents = idleAgents.filter((a) => {
+                    // Estimate idle time based on last heartbeat
+                    const idleTime = now - a.lastHeartbeat;
+                    return idleTime > pool.scaleDownThreshold;
+                });
+                // Prefer removing spot instances first
+                const spotAgents = longIdleAgents.filter((a) => a.instanceType === 'spot');
+                const toRemove = spotAgents.length > 0 ? spotAgents : longIdleAgents;
+                if (toRemove.length > 0) {
+                    const removeCount = Math.min(toRemove.length, poolAgents.length - pool.minAgents);
+                    decisions.push({
+                        pool: poolName,
+                        action: 'scale_down',
+                        count: removeCount,
+                        reason: `${longIdleAgents.length} agents idle for ${pool.scaleDownThreshold}ms`,
+                        agentIds: toRemove.slice(0, removeCount).map((a) => a.id),
+                    });
+                }
+            }
+        }
+        return decisions;
+    }
+    // ─── Stats ─────────────────────────────────────────────
+    getPoolStats(poolName) {
+        const pool = this.pools.get(poolName);
+        if (!pool) {
+            return undefined;
+        }
+        const poolAgents = Array.from(this.agents.values()).filter((a) => a.os === pool.agentTemplate.os);
+        return {
+            poolName,
+            totalAgents: poolAgents.length,
+            idleAgents: poolAgents.filter((a) => a.status === 'idle').length,
+            busyAgents: poolAgents.filter((a) => a.status === 'busy').length,
+            offlineAgents: poolAgents.filter((a) => a.status === 'offline').length,
+            spotAgents: poolAgents.filter((a) => a.instanceType === 'spot').length,
+            dedicatedAgents: poolAgents.filter((a) => a.instanceType === 'dedicated').length,
+            minAgents: pool.minAgents,
+            maxAgents: pool.maxAgents,
+            avgBuildTime: this.calculateAvgBuildTime(poolAgents),
+            totalJobsCompleted: poolAgents.reduce((sum, a) => sum + a.jobsCompleted, 0),
+            totalJobsFailed: poolAgents.reduce((sum, a) => sum + a.jobsFailed, 0),
+        };
+    }
+    calculateAvgBuildTime(agents) {
+        const agentsWithJobs = agents.filter((a) => a.jobsCompleted > 0);
+        if (agentsWithJobs.length === 0) {
+            return 0;
+        }
+        const totalWeightedTime = agentsWithJobs.reduce((sum, a) => sum + a.avgBuildTime * a.jobsCompleted, 0);
+        const totalJobs = agentsWithJobs.reduce((sum, a) => sum + a.jobsCompleted, 0);
+        return totalWeightedTime / totalJobs;
+    }
+    getAllPoolStats() {
+        return Array.from(this.pools.keys())
+            .map((name) => this.getPoolStats(name))
+            .filter(Boolean);
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+class ArtifactStorage {
+    constructor(config) {
+        this.artifacts = new Map();
+        this.config = config;
+    }
+    async uploadArtifact(jobId, name, data, options) {
+        const artifactId = this.generateArtifactId();
+        const path = `${jobId}/${artifactId}/${name}`;
+        // Calculate size and checksum
+        const size = typeof data === 'string' ? data.length : data instanceof Blob ? data.size : data.byteLength;
+        const checksum = await this.calculateChecksum(data);
+        // Check size limit
+        if (size > this.config.maxArtifactSize) {
+            throw new Error(`Artifact size ${size} exceeds limit ${this.config.maxArtifactSize}`);
+        }
+        const retentionDays = options?.retentionDays ?? this.config.retentionDays;
+        const expiresAt = Date.now() + retentionDays * 24 * 60 * 60 * 1000;
+        const artifact = {
+            id: artifactId,
+            jobId,
+            name,
+            path,
+            size,
+            checksum,
+            contentType: options?.contentType ?? 'application/octet-stream',
+            uploadedAt: Date.now(),
+            expiresAt,
+            metadata: options?.metadata ?? {},
+        };
+        // Generate download URL
+        if (this.config.signedUrls) {
+            artifact.downloadUrl = await this.generateSignedUrl(path);
+        }
+        else if (this.config.cdnUrl) {
+            artifact.downloadUrl = `${this.config.cdnUrl}/${path}`;
+        }
+        // In production, this would upload to the actual storage
+        this.artifacts.set(artifactId, artifact);
+        return artifact;
+    }
+    generateArtifactId() {
+        return `art-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    async calculateChecksum(data) {
+        // Simplified checksum - in production use SHA-256
+        let input;
+        if (typeof data === 'string') {
+            input = new TextEncoder().encode(data).buffer;
+        }
+        else if (data instanceof Blob) {
+            input = await data.arrayBuffer();
+        }
+        else {
+            input = data;
+        }
+        const bytes = new Uint8Array(input);
+        let hash = 0;
+        for (let i = 0; i < bytes.length; i++) {
+            hash = ((hash << 5) - hash + bytes[i]) | 0;
+        }
+        return Math.abs(hash).toString(16).padStart(8, '0');
+    }
+    async generateSignedUrl(path) {
+        const expiration = Math.floor(Date.now() / 1000) + this.config.signedUrlExpiration;
+        const signature = await this.generateSignature(path, expiration);
+        const baseUrl = this.config.cdnUrl ?? `${this.config.endpoint}/${this.config.bucket}`;
+        return `${baseUrl}/${path}?expires=${expiration}&signature=${signature}`;
+    }
+    async generateSignature(path, expiration) {
+        // Simplified signature - in production use HMAC-SHA256
+        const data = `${path}:${expiration}:${this.config.secretKey ?? 'secret'}`;
+        let hash = 0;
+        for (let i = 0; i < data.length; i++) {
+            hash = ((hash << 5) - hash + data.charCodeAt(i)) | 0;
+        }
+        return Math.abs(hash).toString(16);
+    }
+    async getArtifact(artifactId) {
+        return this.artifacts.get(artifactId);
+    }
+    async getArtifactsByJob(jobId) {
+        return Array.from(this.artifacts.values()).filter((a) => a.jobId === jobId);
+    }
+    async deleteArtifact(artifactId) {
+        return this.artifacts.delete(artifactId);
+    }
+    async deleteArtifactsByJob(jobId) {
+        let deleted = 0;
+        for (const [id, artifact] of this.artifacts) {
+            if (artifact.jobId === jobId) {
+                this.artifacts.delete(id);
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    async cleanupExpiredArtifacts() {
+        const now = Date.now();
+        let deleted = 0;
+        for (const [id, artifact] of this.artifacts) {
+            if (artifact.expiresAt < now) {
+                this.artifacts.delete(id);
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    getStorageStats() {
+        let totalSize = 0;
+        let artifactCount = 0;
+        for (const artifact of this.artifacts.values()) {
+            totalSize += artifact.size;
+            artifactCount++;
+        }
+        return {
+            artifactCount,
+            totalSize,
+            bucket: this.config.bucket,
+            region: this.config.region,
+        };
+    }
+}
+class BuildNotifications {
+    constructor() {
+        this.configs = new Map();
+    }
+    addConfig(name, config) {
+        this.configs.set(name, config);
+    }
+    removeConfig(name) {
+        return this.configs.delete(name);
+    }
+    getConfig(name) {
+        return this.configs.get(name);
+    }
+    async notify(payload) {
+        const results = [];
+        for (const [name, config] of this.configs) {
+            if (!config.enabled) {
+                continue;
+            }
+            if (!config.events.includes(payload.event)) {
+                continue;
+            }
+            try {
+                await this.sendNotification(config, payload);
+                results.push({ name, success: true });
+            }
+            catch (error) {
+                results.push({
+                    name,
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                });
+            }
+        }
+        return results;
+    }
+    async sendNotification(config, payload) {
+        switch (config.type) {
+            case 'webhook':
+                await this.sendWebhook(config.webhookUrl, payload);
+                break;
+            case 'slack':
+                await this.sendSlack(config.slack, payload);
+                break;
+            case 'discord':
+                await this.sendDiscord(config.discord, payload);
+                break;
+            case 'github':
+                await this.sendGitHubStatus(config.github, payload);
+                break;
+            case 'gitlab':
+                await this.sendGitLabStatus(config.gitlab, payload);
+                break;
+            case 'email':
+                // Email would require SMTP configuration
+                console.log(`Would send email to: ${config.emails?.join(', ')}`);
+                break;
+        }
+    }
+    async sendWebhook(url, payload) {
+        // In production, use fetch
+        console.log(`Webhook to ${url}:`, JSON.stringify(payload));
+    }
+    async sendSlack(config, payload) {
+        const color = this.getStatusColor(payload.job.status);
+        const slackPayload = {
+            channel: config.channel,
+            username: config.username ?? 'Nice2Dev Build',
+            icon_emoji: config.iconEmoji ?? ':hammer:',
+            attachments: [
+                {
+                    color,
+                    title: `Build ${payload.event.replace('_', ' ').toUpperCase()}`,
+                    text: payload.message,
+                    fields: [
+                        { title: 'Job ID', value: payload.job.id, short: true },
+                        { title: 'Engine', value: payload.job.engine, short: true },
+                        { title: 'Platform', value: payload.job.platform, short: true },
+                        { title: 'Status', value: payload.job.status, short: true },
+                    ],
+                    footer: 'Nice2Dev Build Cloud',
+                    ts: Math.floor(payload.timestamp / 1000),
+                },
+            ],
+        };
+        console.log(`Slack webhook:`, JSON.stringify(slackPayload));
+    }
+    async sendDiscord(config, payload) {
+        const color = this.getStatusColorInt(payload.job.status);
+        const discordPayload = {
+            username: config.username ?? 'Nice2Dev Build',
+            avatar_url: config.avatarUrl,
+            embeds: [
+                {
+                    title: `Build ${payload.event.replace('_', ' ').toUpperCase()}`,
+                    description: payload.message,
+                    color,
+                    fields: [
+                        { name: 'Job ID', value: payload.job.id, inline: true },
+                        { name: 'Engine', value: payload.job.engine, inline: true },
+                        { name: 'Platform', value: payload.job.platform, inline: true },
+                        { name: 'Status', value: payload.job.status, inline: true },
+                    ],
+                    footer: { text: 'Nice2Dev Build Cloud' },
+                    timestamp: new Date(payload.timestamp).toISOString(),
+                },
+            ],
+        };
+        console.log(`Discord webhook:`, JSON.stringify(discordPayload));
+    }
+    async sendGitHubStatus(config, payload) {
+        const state = this.getGitHubState(payload.job.status);
+        const statusPayload = {
+            state,
+            target_url: payload.artifactUrl,
+            description: payload.message.slice(0, 140),
+            context: `Nice2Dev/${payload.job.engine}/${payload.job.platform}`,
+        };
+        console.log(`GitHub status for ${config.owner}/${config.repo}:`, JSON.stringify(statusPayload));
+    }
+    async sendGitLabStatus(config, payload) {
+        const state = this.getGitLabState(payload.job.status);
+        const statusPayload = {
+            state,
+            target_url: payload.artifactUrl,
+            description: payload.message.slice(0, 255),
+            name: `Nice2Dev/${payload.job.engine}/${payload.job.platform}`,
+        };
+        console.log(`GitLab status for project ${config.projectId}:`, JSON.stringify(statusPayload));
+    }
+    getStatusColor(status) {
+        const colors = {
+            completed: '#36a64f',
+            failed: '#d00000',
+            cancelled: '#808080',
+            running: '#2196f3',
+            queued: '#ffc107',
+        };
+        return colors[status] ?? '#808080';
+    }
+    getStatusColorInt(status) {
+        const colors = {
+            completed: 0x36a64f,
+            failed: 0xd00000,
+            cancelled: 0x808080,
+            running: 0x2196f3,
+            queued: 0xffc107,
+        };
+        return colors[status] ?? 0x808080;
+    }
+    getGitHubState(status) {
+        const states = {
+            completed: 'success',
+            failed: 'failure',
+            cancelled: 'error',
+            running: 'pending',
+            queued: 'pending',
+        };
+        return states[status] ?? 'pending';
+    }
+    getGitLabState(status) {
+        const states = {
+            completed: 'success',
+            failed: 'failed',
+            cancelled: 'canceled',
+            running: 'running',
+            queued: 'pending',
+        };
+        return states[status] ?? 'pending';
+    }
+}
+class BuildAnalytics {
+    constructor() {
+        this.buildHistory = [];
+        this.data = this.createEmptyData();
+    }
+    createEmptyData() {
+        return {
+            totalBuilds: 0,
+            successfulBuilds: 0,
+            failedBuilds: 0,
+            cancelledBuilds: 0,
+            successRate: 0,
+            avgBuildTime: 0,
+            avgWaitTime: 0,
+            totalBuildTime: 0,
+            buildsByEngine: { unity: 0, godot: 0, unreal: 0, nice2dev: 0 },
+            buildsByPlatform: {},
+            buildsByDay: {},
+            peakConcurrentBuilds: 0,
+            estimatedCost: 0,
+        };
+    }
+    recordBuild(jobId, engine, platform, status, waitTime, buildTime) {
+        const timestamp = Date.now();
+        const day = new Date(timestamp).toISOString().slice(0, 10);
+        this.buildHistory.push({
+            jobId,
+            engine,
+            platform,
+            status,
+            waitTime,
+            buildTime,
+            timestamp,
+        });
+        // Update counters
+        this.data.totalBuilds++;
+        if (status === 'completed') {
+            this.data.successfulBuilds++;
+        }
+        else if (status === 'failed') {
+            this.data.failedBuilds++;
+        }
+        else if (status === 'cancelled') {
+            this.data.cancelledBuilds++;
+        }
+        // Update rates
+        this.data.successRate = this.data.successfulBuilds / this.data.totalBuilds;
+        // Update times
+        this.data.totalBuildTime += buildTime;
+        this.data.avgBuildTime = this.data.totalBuildTime / this.data.totalBuilds;
+        const totalWaitTime = this.buildHistory.reduce((sum, b) => sum + b.waitTime, 0);
+        this.data.avgWaitTime = totalWaitTime / this.buildHistory.length;
+        // Update by engine
+        this.data.buildsByEngine[engine]++;
+        // Update by platform
+        this.data.buildsByPlatform[platform] = (this.data.buildsByPlatform[platform] ?? 0) + 1;
+        // Update by day
+        this.data.buildsByDay[day] = (this.data.buildsByDay[day] ?? 0) + 1;
+        // Update cost estimate (rough: $0.01 per minute)
+        this.data.estimatedCost += (buildTime / 60000) * 0.01;
+    }
+    updateConcurrentBuilds(count) {
+        if (count > this.data.peakConcurrentBuilds) {
+            this.data.peakConcurrentBuilds = count;
+        }
+    }
+    getData() {
+        return { ...this.data };
+    }
+    getDataForPeriod(startDate, endDate) {
+        const startTs = startDate.getTime();
+        const endTs = endDate.getTime();
+        const filteredBuilds = this.buildHistory.filter((b) => b.timestamp >= startTs && b.timestamp <= endTs);
+        const data = this.createEmptyData();
+        for (const build of filteredBuilds) {
+            const day = new Date(build.timestamp).toISOString().slice(0, 10);
+            data.totalBuilds++;
+            if (build.status === 'completed') {
+                data.successfulBuilds++;
+            }
+            else if (build.status === 'failed') {
+                data.failedBuilds++;
+            }
+            else if (build.status === 'cancelled') {
+                data.cancelledBuilds++;
+            }
+            data.totalBuildTime += build.buildTime;
+            data.buildsByEngine[build.engine]++;
+            data.buildsByPlatform[build.platform] = (data.buildsByPlatform[build.platform] ?? 0) + 1;
+            data.buildsByDay[day] = (data.buildsByDay[day] ?? 0) + 1;
+            data.estimatedCost += (build.buildTime / 60000) * 0.01;
+        }
+        if (data.totalBuilds > 0) {
+            data.successRate = data.successfulBuilds / data.totalBuilds;
+            data.avgBuildTime = data.totalBuildTime / data.totalBuilds;
+            data.avgWaitTime =
+                filteredBuilds.reduce((sum, b) => sum + b.waitTime, 0) / filteredBuilds.length;
+        }
+        return data;
+    }
+    getTopPlatforms(limit = 5) {
+        return Object.entries(this.data.buildsByPlatform)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, limit)
+            .map(([platform, count]) => ({ platform, count }));
+    }
+    getRecentBuilds(limit = 10) {
+        return this.buildHistory.slice(-limit).reverse();
+    }
+    clearHistory() {
+        this.buildHistory = [];
+        this.data = this.createEmptyData();
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createBuildQueueManager() {
+    return new BuildQueueManager();
+}
+function createBuildAgentPool() {
+    return new BuildAgentPool();
+}
+function createArtifactStorage(config) {
+    return new ArtifactStorage(config);
+}
+function createBuildNotifications() {
+    return new BuildNotifications();
+}
+function createBuildAnalytics() {
+    return new BuildAnalytics();
+}
+function createBuildOrchestrator(config) {
+    return new BuildOrchestrator(config?.queueManager ?? createBuildQueueManager(), config?.agentPool ?? createBuildAgentPool(), config?.storage ??
+        createArtifactStorage({
+            type: 'local',
+            bucket: 'builds',
+            retentionDays: 7,
+            maxArtifactSize: 5000000000,
+            signedUrls: true,
+            signedUrlExpiration: 3600,
+        }), config?.notifications ?? createBuildNotifications(), config?.analytics ?? createBuildAnalytics());
+}
+// ============================================================
+// Build Orchestrator (combines all components)
+// ============================================================
+class BuildOrchestrator {
+    constructor(queueManager, agentPool, storage, notifications, analytics) {
+        this.queueManager = queueManager;
+        this.agentPool = agentPool;
+        this.storage = storage;
+        this.notifications = notifications;
+        this.analytics = analytics;
+        this.setupCallbacks();
+    }
+    setupCallbacks() {
+        // Wire up queue callbacks
+        this.queueManager.setCallbacks({
+            onJobQueued: (job) => {
+                this.notifications.notify({
+                    event: 'build_queued',
+                    timestamp: Date.now(),
+                    job: {
+                        id: job.id,
+                        userId: job.userId,
+                        engine: job.engine,
+                        platform: job.platform,
+                        status: job.status,
+                    },
+                    message: `Build ${job.id} queued for ${job.engine}/${job.platform}`,
+                });
+            },
+            onJobStarted: (job) => {
+                this.notifications.notify({
+                    event: 'build_started',
+                    timestamp: Date.now(),
+                    job: {
+                        id: job.id,
+                        userId: job.userId,
+                        engine: job.engine,
+                        platform: job.platform,
+                        status: job.status,
+                    },
+                    message: `Build ${job.id} started`,
+                });
+                this.analytics.updateConcurrentBuilds(this.queueManager.getJobsByStatus('running').length);
+            },
+            onJobCompleted: (job) => {
+                const waitTime = job.startedAt - job.createdAt;
+                const buildTime = job.completedAt - job.startedAt;
+                this.analytics.recordBuild(job.id, job.engine, job.platform, job.status, waitTime, buildTime);
+                this.notifications.notify({
+                    event: 'build_completed',
+                    timestamp: Date.now(),
+                    job: {
+                        id: job.id,
+                        userId: job.userId,
+                        engine: job.engine,
+                        platform: job.platform,
+                        status: job.status,
+                    },
+                    message: `Build ${job.id} completed successfully`,
+                    artifactUrl: job.artifacts?.[0]?.downloadUrl,
+                });
+            },
+            onJobFailed: (job, error) => {
+                const waitTime = job.startedAt ? job.startedAt - job.createdAt : 0;
+                const buildTime = job.completedAt && job.startedAt ? job.completedAt - job.startedAt : 0;
+                this.analytics.recordBuild(job.id, job.engine, job.platform, job.status, waitTime, buildTime);
+                this.notifications.notify({
+                    event: 'build_failed',
+                    timestamp: Date.now(),
+                    job: {
+                        id: job.id,
+                        userId: job.userId,
+                        engine: job.engine,
+                        platform: job.platform,
+                        status: job.status,
+                    },
+                    message: `Build ${job.id} failed: ${error}`,
+                    details: { error },
+                });
+            },
+        });
+    }
+    async submitBuild(engine, platform, buildConfig, options) {
+        return this.queueManager.submitJob(engine, platform, buildConfig, options);
+    }
+    getStats() {
+        return {
+            queues: this.queueManager.getAllQueueStats(),
+            pools: this.agentPool.getAllPoolStats(),
+            storage: this.storage.getStorageStats(),
+            analytics: this.analytics.getData(),
+        };
+    }
+}
+
+export { ArtifactStorage, BuildAgentPool, BuildAnalytics, BuildNotifications, BuildOrchestrator, BuildQueueManager, createArtifactStorage, createBuildAgentPool, createBuildAnalytics, createBuildNotifications, createBuildOrchestrator, createBuildQueueManager };
+//# sourceMappingURL=BuildOrchestration.js.map