agent-relay 2.0.22 → 2.0.24

package/packages/cloud/dist/services/capacity-manager.d.ts

@@ -1,148 +0,0 @@
-/**
- * Capacity Manager
- *
- * Tracks workspace capacity across the fleet and provides:
- * - Real-time capacity metrics
- * - Optimal agent placement recommendations
- * - Load balancing decisions
- * - Capacity forecasting based on trends
- *
- * Works with AutoScaler to determine when to provision new instances
- * and with Coordinator to place agents optimally.
- */
-import { EventEmitter } from 'events';
-import { WorkspaceMetrics } from './scaling-policy.js';
-export interface WorkspaceCapacity {
-    workspaceId: string;
-    userId: string;
-    provider: string;
-    region: string;
-    currentAgents: number;
-    maxAgents: number;
-    memoryUsedBytes: number;
-    memoryLimitBytes: number;
-    cpuPercent: number;
-    agentCapacityPercent: number;
-    memoryCapacityPercent: number;
-    overallHealthScore: number;
-    lastHeartbeat: Date;
-    lastMetricsUpdate: Date;
-}
-export interface PlacementRecommendation {
-    workspaceId: string;
-    score: number;
-    reason: string;
-    estimatedCapacityAfter: number;
-}
-export interface CapacitySnapshot {
-    userId: string;
-    totalWorkspaces: number;
-    totalAgents: number;
-    totalMaxAgents: number;
-    totalMemoryBytes: number;
-    totalMemoryLimitBytes: number;
-    averageHealthScore: number;
-    workspaces: WorkspaceCapacity[];
-    timestamp: Date;
-}
-export interface CapacityForecast {
-    userId: string;
-    currentAgents: number;
-    projectedAgents15Min: number;
-    projectedAgents60Min: number;
-    memoryTrendPerMinute: number;
-    willExceedCapacity: boolean;
-    timeToCapacityExhaustion?: number;
-    recommendation: 'none' | 'scale_soon' | 'scale_now' | 'critical';
-}
-export interface CapacityManagerConfig {
-    healthCheckIntervalMs: number;
-    staleThresholdMs: number;
-    memoryWeightFactor: number;
-    agentWeightFactor: number;
-    cpuWeightFactor: number;
-    redisKeyPrefix: string;
-}
-export declare class CapacityManager extends EventEmitter {
-    private config;
-    private redis;
-    private subscriber;
-    private capacityMap;
-    private userWorkspaces;
-    private trendHistory;
-    private healthCheckTimer;
-    constructor(config?: Partial<CapacityManagerConfig>);
-    /**
-     * Initialize with Redis for cross-server sync
-     */
-    initialize(redisUrl: string): Promise<void>;
-    /**
-     * Load capacity data from Redis
-     */
-    private loadFromRedis;
-    /**
-     * Update local capacity map
-     */
-    private updateLocalCapacity;
-    /**
-     * Update trend history for forecasting
-     */
-    private updateTrendHistory;
-    /**
-     * Report capacity from a workspace
-     */
-    reportCapacity(workspaceId: string, userId: string, metrics: Partial<WorkspaceCapacity>): Promise<void>;
-    /**
-     * Calculate health score for a workspace (lower is healthier/better for placement)
-     */
-    private calculateHealthScore;
-    /**
-     * Get best workspace for placing a new agent
-     */
-    recommendPlacement(userId: string, agentCount?: number): PlacementRecommendation[];
-    /**
-     * Generate human-readable placement reason
-     */
-    private getPlacementReason;
-    /**
-     * Get capacity snapshot for a user
-     */
-    getCapacitySnapshot(userId: string): CapacitySnapshot | null;
-    /**
-     * Forecast capacity needs based on trends
-     */
-    getCapacityForecast(userId: string): CapacityForecast | null;
-    /**
-     * Convert workspace metrics to capacity format
-     */
-    fromWorkspaceMetrics(userId: string, metrics: WorkspaceMetrics): Partial<WorkspaceCapacity>;
-    /**
-     * Health check loop - detect stale workspaces
-     */
-    private startHealthCheckLoop;
-    /**
-     * Remove a workspace from tracking
-     */
-    removeWorkspace(workspaceId: string): Promise<void>;
-    /**
-     * Get all workspaces for a user
-     */
-    getUserWorkspaces(userId: string): WorkspaceCapacity[];
-    /**
-     * Get global capacity metrics
-     */
-    getGlobalMetrics(): {
-        totalWorkspaces: number;
-        totalAgents: number;
-        totalMaxAgents: number;
-        averageUtilization: number;
-        staleWorkspaces: number;
-    };
-    /**
-     * Clean shutdown
-     */
-    shutdown(): Promise<void>;
-}
-export declare function getCapacityManager(): CapacityManager;
-export declare function createCapacityManager(config?: Partial<CapacityManagerConfig>): CapacityManager;
-//# sourceMappingURL=capacity-manager.d.ts.map

package/packages/cloud/dist/services/capacity-manager.js

@@ -1,449 +0,0 @@
-/**
- * Capacity Manager
- *
- * Tracks workspace capacity across the fleet and provides:
- * - Real-time capacity metrics
- * - Optimal agent placement recommendations
- * - Load balancing decisions
- * - Capacity forecasting based on trends
- *
- * Works with AutoScaler to determine when to provision new instances
- * and with Coordinator to place agents optimally.
- */
-import { EventEmitter } from 'events';
-import { createClient } from 'redis';
-const DEFAULT_CONFIG = {
-    healthCheckIntervalMs: 15000, // 15 seconds
-    staleThresholdMs: 60000, // 1 minute
-    memoryWeightFactor: 0.4,
-    agentWeightFactor: 0.4,
-    cpuWeightFactor: 0.2,
-    redisKeyPrefix: 'capacity:',
-};
-// Redis channels
-const CHANNELS = {
-    CAPACITY_UPDATE: 'capacity:update',
-    PLACEMENT_REQUEST: 'capacity:placement',
-};
-export class CapacityManager extends EventEmitter {
-    config;
-    redis = null;
-    subscriber = null;
-    capacityMap = new Map();
-    userWorkspaces = new Map(); // userId -> workspaceIds
-    trendHistory = new Map();
-    healthCheckTimer = null;
-    constructor(config = {}) {
-        super();
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Initialize with Redis for cross-server sync
-     */
-    async initialize(redisUrl) {
-        try {
-            this.redis = createClient({ url: redisUrl });
-            this.redis.on('error', (err) => this.emit('error', { context: 'redis', error: err }));
-            this.subscriber = createClient({ url: redisUrl });
-            this.subscriber.on('error', (err) => this.emit('error', { context: 'subscriber', error: err }));
-            await Promise.all([this.redis.connect(), this.subscriber.connect()]);
-            // Subscribe to capacity updates
-            await this.subscriber.subscribe(CHANNELS.CAPACITY_UPDATE, (message) => {
-                try {
-                    const capacity = JSON.parse(message);
-                    capacity.lastHeartbeat = new Date(capacity.lastHeartbeat);
-                    capacity.lastMetricsUpdate = new Date(capacity.lastMetricsUpdate);
-                    this.updateLocalCapacity(capacity);
-                }
-                catch (error) {
-                    this.emit('error', { context: 'capacity_parse', error });
-                }
-            });
-            // Load existing capacity from Redis
-            await this.loadFromRedis();
-            // Start health check loop
-            this.startHealthCheckLoop();
-            this.emit('initialized');
-        }
-        catch (error) {
-            this.emit('error', error);
-            throw error;
-        }
-    }
-    /**
-     * Load capacity data from Redis
-     */
-    async loadFromRedis() {
-        if (!this.redis)
-            return;
-        const keys = await this.redis.keys(`${this.config.redisKeyPrefix}workspace:*`);
-        for (const key of keys) {
-            const data = await this.redis.get(key);
-            if (data) {
-                try {
-                    const capacity = JSON.parse(data);
-                    capacity.lastHeartbeat = new Date(capacity.lastHeartbeat);
-                    capacity.lastMetricsUpdate = new Date(capacity.lastMetricsUpdate);
-                    this.updateLocalCapacity(capacity);
-                }
-                catch {
-                    // Skip invalid entries
-                }
-            }
-        }
-    }
-    /**
-     * Update local capacity map
-     */
-    updateLocalCapacity(capacity) {
-        this.capacityMap.set(capacity.workspaceId, capacity);
-        // Track user -> workspace mapping
-        let userWorkspaceSet = this.userWorkspaces.get(capacity.userId);
-        if (!userWorkspaceSet) {
-            userWorkspaceSet = new Set();
-            this.userWorkspaces.set(capacity.userId, userWorkspaceSet);
-        }
-        userWorkspaceSet.add(capacity.workspaceId);
-        // Update trend history
-        this.updateTrendHistory(capacity);
-        this.emit('capacity_updated', capacity);
-    }
-    /**
-     * Update trend history for forecasting
-     */
-    updateTrendHistory(capacity) {
-        const key = capacity.workspaceId;
-        let history = this.trendHistory.get(key) || [];
-        history.push({
-            timestamp: new Date(),
-            agents: capacity.currentAgents,
-            memory: capacity.memoryUsedBytes,
-        });
-        // Keep only last 30 minutes of history
-        const cutoff = Date.now() - 30 * 60 * 1000;
-        history = history.filter((h) => h.timestamp.getTime() > cutoff);
-        this.trendHistory.set(key, history);
-    }
-    /**
-     * Report capacity from a workspace
-     */
-    async reportCapacity(workspaceId, userId, metrics) {
-        const existing = this.capacityMap.get(workspaceId);
-        const capacity = {
-            workspaceId,
-            userId,
-            provider: metrics.provider || existing?.provider || 'unknown',
-            region: metrics.region || existing?.region || 'unknown',
-            currentAgents: metrics.currentAgents ?? existing?.currentAgents ?? 0,
-            maxAgents: metrics.maxAgents ?? existing?.maxAgents ?? 10,
-            memoryUsedBytes: metrics.memoryUsedBytes ?? existing?.memoryUsedBytes ?? 0,
-            memoryLimitBytes: metrics.memoryLimitBytes ?? existing?.memoryLimitBytes ?? 512 * 1024 * 1024,
-            cpuPercent: metrics.cpuPercent ?? existing?.cpuPercent ?? 0,
-            agentCapacityPercent: 0,
-            memoryCapacityPercent: 0,
-            overallHealthScore: 0,
-            lastHeartbeat: new Date(),
-            lastMetricsUpdate: new Date(),
-        };
-        // Calculate derived metrics
-        capacity.agentCapacityPercent = (capacity.currentAgents / capacity.maxAgents) * 100;
-        capacity.memoryCapacityPercent = (capacity.memoryUsedBytes / capacity.memoryLimitBytes) * 100;
-        capacity.overallHealthScore = this.calculateHealthScore(capacity);
-        // Update local map
-        this.updateLocalCapacity(capacity);
-        // Persist to Redis and broadcast
-        if (this.redis) {
-            const key = `${this.config.redisKeyPrefix}workspace:${workspaceId}`;
-            await this.redis.set(key, JSON.stringify(capacity), { EX: 300 }); // 5 min TTL
-            await this.redis.publish(CHANNELS.CAPACITY_UPDATE, JSON.stringify(capacity));
-        }
-    }
-    /**
-     * Calculate health score for a workspace (lower is healthier/better for placement)
-     */
-    calculateHealthScore(capacity) {
-        const memoryScore = capacity.memoryCapacityPercent * this.config.memoryWeightFactor;
-        const agentScore = capacity.agentCapacityPercent * this.config.agentWeightFactor;
-        const cpuScore = capacity.cpuPercent * this.config.cpuWeightFactor;
-        return memoryScore + agentScore + cpuScore;
-    }
-    /**
-     * Get best workspace for placing a new agent
-     */
-    recommendPlacement(userId, agentCount = 1) {
-        const userWorkspaceIds = this.userWorkspaces.get(userId);
-        if (!userWorkspaceIds || userWorkspaceIds.size === 0) {
-            return [];
-        }
-        const recommendations = [];
-        for (const workspaceId of userWorkspaceIds) {
-            const capacity = this.capacityMap.get(workspaceId);
-            if (!capacity)
-                continue;
-            // Skip stale workspaces
-            if (Date.now() - capacity.lastHeartbeat.getTime() > this.config.staleThresholdMs) {
-                continue;
-            }
-            // Check if workspace can accommodate new agents
-            const availableSlots = capacity.maxAgents - capacity.currentAgents;
-            if (availableSlots < agentCount) {
-                continue;
-            }
-            // Calculate estimated capacity after placement
-            const newAgentCount = capacity.currentAgents + agentCount;
-            const estimatedCapacityAfter = (newAgentCount / capacity.maxAgents) * 100;
-            // Calculate placement score (lower is better)
-            let score = capacity.overallHealthScore;
-            // Penalize workspaces that would be over 80% after placement
-            if (estimatedCapacityAfter > 80) {
-                score += (estimatedCapacityAfter - 80) * 2;
-            }
-            // Bonus for workspaces with room to grow
-            if (estimatedCapacityAfter < 50) {
-                score -= (50 - estimatedCapacityAfter) * 0.5;
-            }
-            const reason = this.getPlacementReason(capacity, estimatedCapacityAfter);
-            recommendations.push({
-                workspaceId,
-                score: Math.max(0, score),
-                reason,
-                estimatedCapacityAfter,
-            });
-        }
-        // Sort by score (lower is better)
-        return recommendations.sort((a, b) => a.score - b.score);
-    }
-    /**
-     * Generate human-readable placement reason
-     */
-    getPlacementReason(capacity, estimatedAfter) {
-        if (capacity.overallHealthScore < 30) {
-            return 'Workspace is healthy with low utilization';
-        }
-        else if (capacity.overallHealthScore < 50) {
-            return 'Workspace has moderate load, good for placement';
-        }
-        else if (capacity.overallHealthScore < 70) {
-            return 'Workspace under load but can accommodate';
-        }
-        else {
-            return `Workspace at ${Math.round(estimatedAfter)}% capacity after placement`;
-        }
-    }
-    /**
-     * Get capacity snapshot for a user
-     */
-    getCapacitySnapshot(userId) {
-        const userWorkspaceIds = this.userWorkspaces.get(userId);
-        if (!userWorkspaceIds || userWorkspaceIds.size === 0) {
-            return null;
-        }
-        const workspaces = [];
-        let totalAgents = 0;
-        let totalMaxAgents = 0;
-        let totalMemory = 0;
-        let totalMemoryLimit = 0;
-        let healthScoreSum = 0;
-        for (const workspaceId of userWorkspaceIds) {
-            const capacity = this.capacityMap.get(workspaceId);
-            if (capacity) {
-                workspaces.push(capacity);
-                totalAgents += capacity.currentAgents;
-                totalMaxAgents += capacity.maxAgents;
-                totalMemory += capacity.memoryUsedBytes;
-                totalMemoryLimit += capacity.memoryLimitBytes;
-                healthScoreSum += capacity.overallHealthScore;
-            }
-        }
-        return {
-            userId,
-            totalWorkspaces: workspaces.length,
-            totalAgents,
-            totalMaxAgents,
-            totalMemoryBytes: totalMemory,
-            totalMemoryLimitBytes: totalMemoryLimit,
-            averageHealthScore: workspaces.length > 0 ? healthScoreSum / workspaces.length : 0,
-            workspaces,
-            timestamp: new Date(),
-        };
-    }
-    /**
-     * Forecast capacity needs based on trends
-     */
-    getCapacityForecast(userId) {
-        const snapshot = this.getCapacitySnapshot(userId);
-        if (!snapshot)
-            return null;
-        // Calculate aggregate trends
-        let totalAgentTrend = 0;
-        let totalMemoryTrend = 0;
-        let trendSamples = 0;
-        for (const workspace of snapshot.workspaces) {
-            const history = this.trendHistory.get(workspace.workspaceId);
-            if (!history || history.length < 2)
-                continue;
-            const oldest = history[0];
-            const newest = history[history.length - 1];
-            const timeSpanMinutes = (newest.timestamp.getTime() - oldest.timestamp.getTime()) / (1000 * 60);
-            if (timeSpanMinutes > 0) {
-                totalAgentTrend += (newest.agents - oldest.agents) / timeSpanMinutes;
-                totalMemoryTrend += (newest.memory - oldest.memory) / timeSpanMinutes;
-                trendSamples++;
-            }
-        }
-        // Average trends
-        const avgAgentTrend = trendSamples > 0 ? totalAgentTrend / trendSamples : 0;
-        const avgMemoryTrend = trendSamples > 0 ? totalMemoryTrend / trendSamples : 0;
-        // Project future state
-        const projectedAgents15Min = Math.max(0, snapshot.totalAgents + avgAgentTrend * 15);
-        const projectedAgents60Min = Math.max(0, snapshot.totalAgents + avgAgentTrend * 60);
-        // Check if we'll exceed capacity
-        const willExceedCapacity = projectedAgents60Min >= snapshot.totalMaxAgents * 0.9;
-        // Calculate time to capacity exhaustion
-        let timeToExhaustion;
-        if (avgAgentTrend > 0) {
-            const remainingSlots = snapshot.totalMaxAgents - snapshot.totalAgents;
-            timeToExhaustion = remainingSlots / avgAgentTrend;
-        }
-        // Generate recommendation
-        let recommendation = 'none';
-        if (snapshot.totalAgents >= snapshot.totalMaxAgents * 0.95) {
-            recommendation = 'critical';
-        }
-        else if (snapshot.totalAgents >= snapshot.totalMaxAgents * 0.85) {
-            recommendation = 'scale_now';
-        }
-        else if (willExceedCapacity || projectedAgents15Min >= snapshot.totalMaxAgents * 0.8) {
-            recommendation = 'scale_soon';
-        }
-        return {
-            userId,
-            currentAgents: snapshot.totalAgents,
-            projectedAgents15Min: Math.round(projectedAgents15Min),
-            projectedAgents60Min: Math.round(projectedAgents60Min),
-            memoryTrendPerMinute: avgMemoryTrend,
-            willExceedCapacity,
-            timeToCapacityExhaustion: timeToExhaustion,
-            recommendation,
-        };
-    }
-    /**
-     * Convert workspace metrics to capacity format
-     */
-    fromWorkspaceMetrics(userId, metrics) {
-        return {
-            workspaceId: metrics.workspaceId,
-            userId,
-            currentAgents: metrics.agentCount,
-            memoryUsedBytes: metrics.totalMemoryBytes,
-            cpuPercent: metrics.cpuPercent,
-        };
-    }
-    /**
-     * Health check loop - detect stale workspaces
-     */
-    startHealthCheckLoop() {
-        if (this.healthCheckTimer) {
-            clearInterval(this.healthCheckTimer);
-        }
-        this.healthCheckTimer = setInterval(() => {
-            const now = Date.now();
-            for (const [workspaceId, capacity] of this.capacityMap) {
-                if (now - capacity.lastHeartbeat.getTime() > this.config.staleThresholdMs) {
-                    this.emit('workspace_stale', { workspaceId, lastHeartbeat: capacity.lastHeartbeat });
-                }
-            }
-        }, this.config.healthCheckIntervalMs);
-    }
-    /**
-     * Remove a workspace from tracking
-     */
-    async removeWorkspace(workspaceId) {
-        const capacity = this.capacityMap.get(workspaceId);
-        if (capacity) {
-            this.capacityMap.delete(workspaceId);
-            this.trendHistory.delete(workspaceId);
-            const userWorkspaceSet = this.userWorkspaces.get(capacity.userId);
-            if (userWorkspaceSet) {
-                userWorkspaceSet.delete(workspaceId);
-            }
-            if (this.redis) {
-                await this.redis.del(`${this.config.redisKeyPrefix}workspace:${workspaceId}`);
-            }
-            this.emit('workspace_removed', workspaceId);
-        }
-    }
-    /**
-     * Get all workspaces for a user
-     */
-    getUserWorkspaces(userId) {
-        const workspaceIds = this.userWorkspaces.get(userId);
-        if (!workspaceIds)
-            return [];
-        const workspaces = [];
-        for (const id of workspaceIds) {
-            const capacity = this.capacityMap.get(id);
-            if (capacity) {
-                workspaces.push(capacity);
-            }
-        }
-        return workspaces;
-    }
-    /**
-     * Get global capacity metrics
-     */
-    getGlobalMetrics() {
-        let totalAgents = 0;
-        let totalMaxAgents = 0;
-        let utilizationSum = 0;
-        let staleCount = 0;
-        const now = Date.now();
-        for (const capacity of this.capacityMap.values()) {
-            totalAgents += capacity.currentAgents;
-            totalMaxAgents += capacity.maxAgents;
-            utilizationSum += capacity.overallHealthScore;
-            if (now - capacity.lastHeartbeat.getTime() > this.config.staleThresholdMs) {
-                staleCount++;
-            }
-        }
-        return {
-            totalWorkspaces: this.capacityMap.size,
-            totalAgents,
-            totalMaxAgents,
-            averageUtilization: this.capacityMap.size > 0 ? utilizationSum / this.capacityMap.size : 0,
-            staleWorkspaces: staleCount,
-        };
-    }
-    /**
-     * Clean shutdown
-     */
-    async shutdown() {
-        if (this.healthCheckTimer) {
-            clearInterval(this.healthCheckTimer);
-            this.healthCheckTimer = null;
-        }
-        if (this.subscriber) {
-            await this.subscriber.unsubscribe();
-            await this.subscriber.quit();
-            this.subscriber = null;
-        }
-        if (this.redis) {
-            await this.redis.quit();
-            this.redis = null;
-        }
-        this.emit('shutdown');
-    }
-}
-// Singleton instance
-let _capacityManager = null;
-export function getCapacityManager() {
-    if (!_capacityManager) {
-        _capacityManager = new CapacityManager();
-    }
-    return _capacityManager;
-}
-export function createCapacityManager(config = {}) {
-    _capacityManager = new CapacityManager(config);
-    return _capacityManager;
-}
-//# sourceMappingURL=capacity-manager.js.map

package/packages/cloud/dist/services/ci-agent-spawner.d.ts

@@ -1,49 +0,0 @@
-/**
- * CI Agent Spawner Service
- *
- * Spawns agents to fix CI failures automatically.
- * Called by the webhook handler when CI checks fail on PRs.
- *
- * Flow:
- * 1. App posts acknowledgment comment on the PR
- * 2. Finds a linked daemon for the repository
- * 3. Queues spawn command for the daemon
- * 4. Agent works and posts response comment
- */
-import { CIFailureEvent } from '../db/index.js';
-/**
- * Spawn an agent to fix CI failures
- *
- * This function:
- * 1. Finds the workspace for the repository
- * 2. Posts acknowledgment comment
- * 3. Creates a fix attempt record
- * 4. Queues spawn command for a linked daemon
- *
- * @param failureEvent - The CI failure event from the database
- */
-export declare function spawnCIFixAgent(failureEvent: CIFailureEvent): Promise<void>;
-/**
- * Notify an existing agent about a CI failure
- *
- * Used when an agent is already working on a PR and a new failure occurs.
- *
- * @param agentId - The ID of the existing agent
- * @param failureEvent - The new CI failure event
- */
-export declare function notifyAgentOfCIFailure(agentId: string, failureEvent: CIFailureEvent): Promise<void>;
-/**
- * Mark a fix attempt as complete
- *
- * Called when an agent reports completion (success or failure)
- */
-export declare function completeFixAttempt(fixAttemptId: string, success: boolean, commitSha?: string, errorMessage?: string): Promise<void>;
-/**
- * Get failure history for a repository
- */
-export declare function getFailureHistory(repository: string, limit?: number): Promise<CIFailureEvent[]>;
-/**
- * Get failure history for a specific PR
- */
-export declare function getPRFailureHistory(repository: string, prNumber: number): Promise<CIFailureEvent[]>;
-//# sourceMappingURL=ci-agent-spawner.d.ts.map