agent-relay 1.1.0 → 1.2.3

package/dist/cloud/services/planLimits.d.ts

@@ -14,6 +14,8 @@ export interface PlanLimits {
     maxConcurrentAgents: number;
     maxComputeHoursPerMonth: number;
     coordinatorsEnabled: boolean;
+    /** Cloud session persistence (summaries, session tracking) - Pro+ only */
+    sessionPersistence: boolean;
 }
 /**
  * Plan limits configuration
@@ -76,6 +78,19 @@ export declare function canUseCoordinator(userId: string): Promise<{
     reason?: string;
     requiredPlan?: string;
 }>;
+/**
+ * Check if user can use cloud session persistence
+ *
+ * Session persistence enables:
+ * - [[SUMMARY]] blocks saved to cloud database
+ * - [[SESSION_END]] markers for session tracking
+ * - Session recovery and handoff between agents
+ */
+export declare function canUseSessionPersistence(userId: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+    requiredPlan?: string;
+}>;
 /**
  * Check if user has compute hours available
  */
@@ -107,4 +122,26 @@ export declare function recordComputeUsage(userId: string, workspaceId: string,
  * Update active agent count for a user
  */
 export declare function updateActiveAgentCount(userId: string, workspaceId: string, count: number): Promise<void>;
+/**
+ * Resource tier name type
+ */
+export type ResourceTierName = 'small' | 'medium' | 'large' | 'xlarge';
+/**
+ * Get the default resource tier for a plan
+ * Maps plans to appropriate compute resources
+ */
+export declare function getResourceTierForPlan(plan: PlanType): ResourceTierName;
+/**
+ * Get the maximum resource tier a plan can scale to
+ * Prevents over-scaling beyond plan entitlements
+ */
+export declare function getMaxResourceTierForPlan(plan: PlanType): ResourceTierName;
+/**
+ * Check if user's plan allows auto-scaling
+ */
+export declare function canAutoScale(plan: PlanType): boolean;
+/**
+ * Check if auto-scale to a specific tier is allowed for a plan
+ */
+export declare function canScaleToTier(plan: PlanType, targetTier: ResourceTierName): boolean;
 //# sourceMappingURL=planLimits.d.ts.map

package/dist/cloud/services/planLimits.js

@@ -18,17 +18,19 @@ import { getDb } from '../db/drizzle.js';
 export const PLAN_LIMITS = {
     free: {
         maxWorkspaces: 1,
-        maxRepos: 3,
+        maxRepos: 2,
         maxConcurrentAgents: 2,
-        maxComputeHoursPerMonth: 10,
+        maxComputeHoursPerMonth: 5, // Limited free tier
         coordinatorsEnabled: false,
+        sessionPersistence: false,
     },
     pro: {
         maxWorkspaces: 5,
-        maxRepos: 20,
-        maxConcurrentAgents: 10,
-        maxComputeHoursPerMonth: 100,
+        maxRepos: 10,
+        maxConcurrentAgents: 5,
+        maxComputeHoursPerMonth: 50,
         coordinatorsEnabled: true,
+        sessionPersistence: true,
     },
     team: {
         maxWorkspaces: 20,
@@ -36,6 +38,7 @@ export const PLAN_LIMITS = {
         maxConcurrentAgents: 50,
         maxComputeHoursPerMonth: 500,
         coordinatorsEnabled: true,
+        sessionPersistence: true,
     },
     enterprise: {
         maxWorkspaces: Infinity,
@@ -43,6 +46,7 @@ export const PLAN_LIMITS = {
         maxConcurrentAgents: Infinity,
         maxComputeHoursPerMonth: Infinity,
         coordinatorsEnabled: true,
+        sessionPersistence: true,
     },
 };
 /**
@@ -179,6 +183,30 @@ export async function canUseCoordinator(userId) {
     }
     return { allowed: true };
 }
+/**
+ * Check if user can use cloud session persistence
+ *
+ * Session persistence enables:
+ * - [[SUMMARY]] blocks saved to cloud database
+ * - [[SESSION_END]] markers for session tracking
+ * - Session recovery and handoff between agents
+ */
+export async function canUseSessionPersistence(userId) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { allowed: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    if (!limits.sessionPersistence) {
+        return {
+            allowed: false,
+            reason: 'Cloud session persistence requires a Pro plan or higher',
+            requiredPlan: 'pro',
+        };
+    }
+    return { allowed: true };
+}
 /**
  * Check if user has compute hours available
  */
@@ -251,4 +279,57 @@ export async function updateActiveAgentCount(userId, workspaceId, count) {
         recordedAt: new Date(),
     });
 }
+/**
+ * Get the default resource tier for a plan
+ * Maps plans to appropriate compute resources
+ */
+export function getResourceTierForPlan(plan) {
+    switch (plan) {
+        case 'free':
+            return 'small'; // 2GB, 2 CPUs - suitable for 2 agents
+        case 'pro':
+            return 'medium'; // 4GB, 4 CPUs - suitable for 5 agents
+        case 'team':
+            return 'large'; // 8GB, 4 CPUs - suitable for 10 agents
+        case 'enterprise':
+            return 'xlarge'; // 16GB, 8 CPUs - suitable for 20 agents
+        default:
+            return 'small';
+    }
+}
+/**
+ * Get the maximum resource tier a plan can scale to
+ * Prevents over-scaling beyond plan entitlements
+ */
+export function getMaxResourceTierForPlan(plan) {
+    switch (plan) {
+        case 'free':
+            return 'small'; // Free tier cannot scale up
+        case 'pro':
+            return 'medium'; // Pro can scale to medium
+        case 'team':
+            return 'large'; // Team can scale to large
+        case 'enterprise':
+            return 'xlarge'; // Enterprise can use any tier
+        default:
+            return 'small';
+    }
+}
+/**
+ * Check if user's plan allows auto-scaling
+ */
+export function canAutoScale(plan) {
+    // Only Pro and above can auto-scale
+    return plan !== 'free';
+}
+/**
+ * Check if auto-scale to a specific tier is allowed for a plan
+ */
+export function canScaleToTier(plan, targetTier) {
+    const tierOrder = ['small', 'medium', 'large', 'xlarge'];
+    const maxTier = getMaxResourceTierForPlan(plan);
+    const targetIndex = tierOrder.indexOf(targetTier);
+    const maxIndex = tierOrder.indexOf(maxTier);
+    return targetIndex <= maxIndex;
+}
 //# sourceMappingURL=planLimits.js.map

package/dist/cloud/services/scaling-orchestrator.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Scaling Orchestrator
+ *
+ * Main integration layer that connects:
+ * - AutoScaler (policy evaluation and scaling decisions)
+ * - CapacityManager (workspace capacity tracking)
+ * - WorkspaceProvisioner (actual instance provisioning)
+ * - Monitoring (memory/CPU metrics from agents)
+ *
+ * Handles the complete scaling lifecycle:
+ * 1. Receives metrics from monitoring
+ * 2. Updates capacity manager
+ * 3. Triggers auto-scaler evaluation
+ * 4. Executes scaling via provisioner
+ * 5. Updates capacity after scaling
+ */
+import { EventEmitter } from 'events';
+import { ScalingOperation } from './auto-scaler.js';
+import { CapacityForecast } from './capacity-manager.js';
+import { ScalingDecision, WorkspaceMetrics } from './scaling-policy.js';
+import { ProvisionResult } from '../provisioner/index.js';
+export interface ScalingEvent {
+    type: 'scale_up' | 'scale_down' | 'resize_up' | 'resize_down' | 'increase_agent_limit' | 'migrate_agents' | 'rebalance' | 'alert';
+    userId: string;
+    workspaceId?: string;
+    decision?: ScalingDecision;
+    operation?: ScalingOperation;
+    result?: ProvisionResult;
+    previousTier?: string;
+    newTier?: string;
+    previousAgentLimit?: number;
+    newAgentLimit?: number;
+    error?: string;
+    timestamp: Date;
+}
+export interface OrchestratorConfig {
+    enabled: boolean;
+    redisUrl?: string;
+    autoProvision: boolean;
+    autoDeprovision: boolean;
+    idleTimeoutMs: number;
+    minUserWorkspaces: number;
+}
+export declare class ScalingOrchestrator extends EventEmitter {
+    private config;
+    private autoScaler;
+    private capacityManager;
+    private provisioner;
+    private initialized;
+    private scalingHistory;
+    private maxHistorySize;
+    constructor(config?: Partial<OrchestratorConfig>);
+    /**
+     * Initialize the orchestrator with Redis for cross-server coordination
+     */
+    initialize(redisUrl?: string): Promise<void>;
+    /**
+     * Set up event handlers between components
+     */
+    private setupEventHandlers;
+    /**
+     * Check if scaling is needed for a user
+     */
+    private checkScalingNeeded;
+    /**
+     * Execute a scaling operation
+     */
+    private executeScaling;
+    /**
+     * Handle scale up - provision new workspace
+     */
+    private handleScaleUp;
+    /**
+     * Handle scale down - deprovision workspace
+     */
+    private handleScaleDown;
+    /**
+     * Handle rebalance - redistribute agents across workspaces
+     */
+    private handleRebalance;
+    /**
+     * Handle resize - vertical scaling (increase/decrease workspace resources)
+     */
+    private handleResize;
+    /**
+     * Handle agent limit increase within a workspace
+     */
+    private handleAgentLimitIncrease;
+    /**
+     * Handle agent migration between workspaces
+     */
+    private handleMigrateAgents;
+    /**
+     * Record a scaling event in history
+     */
+    private recordEvent;
+    /**
+     * Persist scaling event to database
+     */
+    private persistScalingEvent;
+    /**
+     * Report metrics from monitoring service
+     * This is the main entry point for metrics from agents
+     */
+    reportMetrics(userId: string, workspaces: WorkspaceMetrics[]): Promise<void>;
+    /**
+     * Manually trigger scaling evaluation for a user
+     */
+    evaluateScaling(userId: string): Promise<ScalingDecision | null>;
+    /**
+     * Get capacity forecast for a user
+     */
+    getCapacityForecast(userId: string): CapacityForecast | null;
+    /**
+     * Get best placement for new agents
+     */
+    recommendPlacement(userId: string, agentCount?: number): import("./capacity-manager.js").PlacementRecommendation[];
+    /**
+     * Get scaling history for a user
+     */
+    getScalingHistory(userId?: string): ScalingEvent[];
+    /**
+     * Get current status of the orchestrator
+     */
+    getStatus(): {
+        initialized: boolean;
+        autoScaler: {
+            enabled: boolean;
+            isLeader: boolean;
+            serverId: string;
+            pendingOperations: number;
+            cachedUsers: number;
+        };
+        capacity: {
+            totalWorkspaces: number;
+            totalAgents: number;
+            totalMaxAgents: number;
+            averageUtilization: number;
+            staleWorkspaces: number;
+        };
+        config: {
+            autoProvision: boolean;
+            autoDeprovision: boolean;
+            minUserWorkspaces: number;
+        };
+        historySize: number;
+    };
+    /**
+     * Update user's plan tier
+     */
+    setUserPlan(userId: string, plan: 'free' | 'pro' | 'team' | 'enterprise'): Promise<void>;
+    /**
+     * Clean shutdown
+     */
+    shutdown(): Promise<void>;
+}
+export declare function getScalingOrchestrator(): ScalingOrchestrator;
+export declare function createScalingOrchestrator(config?: Partial<OrchestratorConfig>): ScalingOrchestrator;
+//# sourceMappingURL=scaling-orchestrator.d.ts.map