agent-relay 2.0.22 → 2.0.24

package/packages/cloud/dist/services/persistence.js

@@ -1,200 +0,0 @@
-/**
- * Cloud Persistence Service
- *
- * Handles durable persistence of agent session data for cloud deployments.
- * Subscribes to wrapper events ('summary', 'session-end') and persists
- * to PostgreSQL via Drizzle ORM.
- *
- * This decouples wrappers from storage concerns - the wrapper emits events,
- * this service handles persistence. Different storage backends can be swapped
- * by implementing alternative persistence services.
- *
- * @see RelayPtyOrchestratorEvents in src/wrapper/relay-pty-orchestrator.ts for event definitions
- */
-import { eq, and, desc } from 'drizzle-orm';
-import { getDb } from '../db/drizzle.js';
-import { agentSessions, agentSummaries } from '../db/schema.js';
-/**
- * CloudPersistenceService manages durable storage for agent sessions.
- *
- * Usage:
- * ```typescript
- * const persistence = new CloudPersistenceService({
- *   workspaceId: 'workspace-123',
- * });
- *
- * // Bind to a RelayPtyOrchestrator instance
- * const pty = new RelayPtyOrchestrator(config);
- * const sessionId = await persistence.bindToWrapper(pty);
- *
- * // When done, unbind to clean up listeners
- * persistence.unbindFromWrapper(pty);
- * ```
- */
-export class CloudPersistenceService {
-    config;
-    boundWrappers = new Map();
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Bind to a RelayPtyOrchestrator instance and start persisting its events.
-     * Creates a new agent session record and returns the session ID.
-     *
-     * @param wrapper The RelayPtyOrchestrator to bind to
-     * @returns The session ID for this agent session
-     */
-    async bindToRelayPtyOrchestrator(wrapper) {
-        const db = getDb();
-        const agentName = wrapper.name;
-        // Create session record
-        const result = await db.insert(agentSessions).values({
-            workspaceId: this.config.workspaceId,
-            agentName,
-            status: 'active',
-            startedAt: new Date(),
-        }).returning();
-        const session = result[0];
-        if (!session) {
-            throw new Error(`Failed to create session for agent ${agentName}`);
-        }
-        const sessionId = session.id;
-        // Create event handlers
-        const summaryHandler = async (event) => {
-            await this.handleSummary(sessionId, event);
-        };
-        const sessionEndHandler = async (event) => {
-            await this.handleSessionEnd(sessionId, event);
-        };
-        // Bind handlers
-        wrapper.on('summary', summaryHandler);
-        wrapper.on('session-end', sessionEndHandler);
-        // Track binding for cleanup
-        this.boundWrappers.set(wrapper, {
-            sessionId,
-            summaryHandler,
-            sessionEndHandler,
-        });
-        console.log(`[persistence] Bound to ${agentName}, session=${sessionId}`);
-        return sessionId;
-    }
-    /**
-     * Unbind from a RelayPtyOrchestrator and clean up event listeners.
-     *
-     * @param wrapper The RelayPtyOrchestrator to unbind from
-     */
-    unbindFromRelayPtyOrchestrator(wrapper) {
-        const binding = this.boundWrappers.get(wrapper);
-        if (!binding)
-            return;
-        wrapper.off('summary', binding.summaryHandler);
-        wrapper.off('session-end', binding.sessionEndHandler);
-        this.boundWrappers.delete(wrapper);
-        console.log(`[persistence] Unbound from ${wrapper.name}`);
-    }
-    /**
-     * Handle a summary event - persist to agent_summaries table.
-     */
-    async handleSummary(sessionId, event) {
-        try {
-            const db = getDb();
-            const result = await db.insert(agentSummaries).values({
-                sessionId,
-                agentName: event.agentName,
-                summary: event.summary,
-                createdAt: new Date(),
-            }).returning();
-            const summaryRecord = result[0];
-            if (!summaryRecord) {
-                console.error(`[persistence] Insert returned no record for ${event.agentName}`);
-                return;
-            }
-            console.log(`[persistence] Saved summary for ${event.agentName}: ${event.summary.currentTask || 'no task'}`);
-            this.config.onSummaryPersisted?.(event.agentName, summaryRecord.id);
-        }
-        catch (err) {
-            console.error(`[persistence] Failed to save summary for ${event.agentName}:`, err);
-        }
-    }
-    /**
-     * Handle a session-end event - update agent_sessions with end marker.
-     */
-    async handleSessionEnd(sessionId, event) {
-        try {
-            const db = getDb();
-            await db.update(agentSessions)
-                .set({
-                status: 'ended',
-                endedAt: new Date(),
-                endMarker: event.marker,
-            })
-                .where(eq(agentSessions.id, sessionId));
-            console.log(`[persistence] Session ended for ${event.agentName}: ${event.marker.summary || 'no summary'}`);
-            this.config.onSessionEnded?.(event.agentName, sessionId);
-        }
-        catch (err) {
-            console.error(`[persistence] Failed to end session for ${event.agentName}:`, err);
-        }
-    }
-    /**
-     * Get the session ID for a bound wrapper.
-     */
-    getSessionId(wrapper) {
-        return this.boundWrappers.get(wrapper)?.sessionId;
-    }
-    /**
-     * Get all summaries for a session.
-     */
-    async getSessionSummaries(sessionId) {
-        const db = getDb();
-        return db.select()
-            .from(agentSummaries)
-            .where(eq(agentSummaries.sessionId, sessionId))
-            .orderBy(agentSummaries.createdAt);
-    }
-    /**
-     * Get the latest summary for an agent in THIS workspace.
-     * Joins through agent_sessions to ensure workspace scoping.
-     */
-    async getLatestSummary(agentName) {
-        const db = getDb();
-        // Join with sessions to ensure we only get summaries from this workspace
-        const results = await db.select({
-            id: agentSummaries.id,
-            sessionId: agentSummaries.sessionId,
-            agentName: agentSummaries.agentName,
-            summary: agentSummaries.summary,
-            createdAt: agentSummaries.createdAt,
-        })
-            .from(agentSummaries)
-            .innerJoin(agentSessions, eq(agentSummaries.sessionId, agentSessions.id))
-            .where(and(eq(agentSummaries.agentName, agentName), eq(agentSessions.workspaceId, this.config.workspaceId)))
-            .orderBy(desc(agentSummaries.createdAt))
-            .limit(1);
-        return results[0] || null;
-    }
-    /**
-     * Get active sessions for a workspace.
-     */
-    async getActiveSessions() {
-        const db = getDb();
-        return db.select()
-            .from(agentSessions)
-            .where(and(eq(agentSessions.workspaceId, this.config.workspaceId), eq(agentSessions.status, 'active')));
-    }
-    /**
-     * Clean up all bindings.
-     */
-    destroy() {
-        for (const wrapper of this.boundWrappers.keys()) {
-            this.unbindFromRelayPtyOrchestrator(wrapper);
-        }
-    }
-}
-/**
- * Factory function to create a persistence service for a workspace.
- */
-export function createPersistenceService(workspaceId) {
-    return new CloudPersistenceService({ workspaceId });
-}
-//# sourceMappingURL=persistence.js.map

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

@@ -1,147 +0,0 @@
-/**
- * Plan Limits Service
- *
- * Defines resource limits for each plan tier and provides
- * functions to check if users are within their limits.
- */
-import { PlanType } from '../db/index.js';
-/**
- * Resource limits for each plan tier
- */
-export interface PlanLimits {
-    maxWorkspaces: number;
-    maxRepos: number;
-    maxConcurrentAgents: number;
-    maxComputeHoursPerMonth: number;
-    coordinatorsEnabled: boolean;
-    /** Cloud session persistence (summaries, session tracking) - Pro+ only */
-    sessionPersistence: boolean;
-}
-/**
- * Plan limits configuration
- *
- * Free: Try it out on a side project
- * Pro: Professional developers, coordinators enabled
- * Team: Growing teams with advanced needs
- * Enterprise: Unlimited everything
- */
-export declare const PLAN_LIMITS: Record<PlanType, PlanLimits>;
-/**
- * Get plan limits for a given plan type
- */
-export declare function getPlanLimits(plan: PlanType): PlanLimits;
-/**
- * Current usage for a user
- */
-export interface UserUsage {
-    workspaceCount: number;
-    repoCount: number;
-    concurrentAgents: number;
-    computeHoursThisMonth: number;
-}
-/**
- * Get current usage for a user
- */
-export declare function getUserUsage(userId: string): Promise<UserUsage>;
-/**
- * Check if user can create a new workspace
- */
-export declare function canCreateWorkspace(userId: string): Promise<{
-    allowed: boolean;
-    reason?: string;
-    limit?: number;
-    current?: number;
-}>;
-/**
- * Check if user can add a new repo
- */
-export declare function canAddRepo(userId: string): Promise<{
-    allowed: boolean;
-    reason?: string;
-    limit?: number;
-    current?: number;
-}>;
-/**
- * Check if user can spawn another agent (concurrent agent limit)
- */
-export declare function canSpawnAgent(userId: string, currentRunningAgents?: number): Promise<{
-    allowed: boolean;
-    reason?: string;
-    limit?: number;
-    current?: number;
-}>;
-/**
- * Check if user can use coordinator agents
- */
-export declare function canUseCoordinator(userId: string): Promise<{
-    allowed: boolean;
-    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
- */
-export declare function hasComputeHoursAvailable(userId: string): Promise<{
-    available: boolean;
-    reason?: string;
-    limit?: number;
-    current?: number;
-}>;
-/**
- * Get remaining quota for a user
- */
-export declare function getRemainingQuota(userId: string): Promise<{
-    plan: PlanType;
-    limits: PlanLimits;
-    usage: UserUsage;
-    remaining: {
-        workspaces: number;
-        repos: number;
-        concurrentAgents: number;
-        computeHours: number;
-    };
-}>;
-/**
- * Record compute usage
- */
-export declare function recordComputeUsage(userId: string, workspaceId: string, hours: number): Promise<void>;
-/**
- * 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/packages/cloud/dist/services/planLimits.js

@@ -1,335 +0,0 @@
-/**
- * Plan Limits Service
- *
- * Defines resource limits for each plan tier and provides
- * functions to check if users are within their limits.
- */
-import { db, usageRecordsTable } from '../db/index.js';
-import { eq, and, gte, sql } from 'drizzle-orm';
-import { getDb } from '../db/drizzle.js';
-/**
- * Plan limits configuration
- *
- * Free: Try it out on a side project
- * Pro: Professional developers, coordinators enabled
- * Team: Growing teams with advanced needs
- * Enterprise: Unlimited everything
- */
-export const PLAN_LIMITS = {
-    free: {
-        maxWorkspaces: 1,
-        maxRepos: 2,
-        maxConcurrentAgents: 2,
-        maxComputeHoursPerMonth: 5, // Limited free tier
-        coordinatorsEnabled: false,
-        sessionPersistence: false,
-    },
-    pro: {
-        maxWorkspaces: 5,
-        maxRepos: 10,
-        maxConcurrentAgents: 5,
-        maxComputeHoursPerMonth: 50,
-        coordinatorsEnabled: true,
-        sessionPersistence: true,
-    },
-    team: {
-        maxWorkspaces: 20,
-        maxRepos: 100,
-        maxConcurrentAgents: 50,
-        maxComputeHoursPerMonth: 500,
-        coordinatorsEnabled: true,
-        sessionPersistence: true,
-    },
-    enterprise: {
-        maxWorkspaces: Infinity,
-        maxRepos: Infinity,
-        maxConcurrentAgents: Infinity,
-        maxComputeHoursPerMonth: Infinity,
-        coordinatorsEnabled: true,
-        sessionPersistence: true,
-    },
-};
-/**
- * Get plan limits for a given plan type
- */
-export function getPlanLimits(plan) {
-    return PLAN_LIMITS[plan];
-}
-/**
- * Get current usage for a user
- */
-export async function getUserUsage(userId) {
-    // Get workspace count
-    const workspaces = await db.workspaces.findByUserId(userId);
-    const workspaceCount = workspaces.length;
-    // Get repo count across all workspaces
-    let repoCount = 0;
-    for (const workspace of workspaces) {
-        const repos = await db.repositories.findByWorkspaceId(workspace.id);
-        repoCount += repos.length;
-    }
-    // Get concurrent agents (currently running)
-    // For now, we'll track this via usage_records with metric 'active_agents'
-    // In production, this would query the actual running agent count
-    const drizzleDb = getDb();
-    const activeAgentsResult = await drizzleDb
-        .select({ total: sql `COALESCE(MAX(${usageRecordsTable.value}), 0)` })
-        .from(usageRecordsTable)
-        .where(and(eq(usageRecordsTable.userId, userId), eq(usageRecordsTable.metric, 'active_agents')));
-    const concurrentAgents = Number(activeAgentsResult[0]?.total || 0);
-    // Get compute hours this month
-    const startOfMonth = new Date();
-    startOfMonth.setDate(1);
-    startOfMonth.setHours(0, 0, 0, 0);
-    const computeHoursResult = await drizzleDb
-        .select({ total: sql `COALESCE(SUM(${usageRecordsTable.value}), 0)` })
-        .from(usageRecordsTable)
-        .where(and(eq(usageRecordsTable.userId, userId), eq(usageRecordsTable.metric, 'compute_hours'), gte(usageRecordsTable.recordedAt, startOfMonth)));
-    const computeHoursThisMonth = Number(computeHoursResult[0]?.total || 0);
-    return {
-        workspaceCount,
-        repoCount,
-        concurrentAgents,
-        computeHoursThisMonth,
-    };
-}
-/**
- * Check if user can create a new workspace
- */
-export async function canCreateWorkspace(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);
-    const usage = await getUserUsage(userId);
-    if (usage.workspaceCount >= limits.maxWorkspaces) {
-        return {
-            allowed: false,
-            reason: `Workspace limit reached for ${plan} plan`,
-            limit: limits.maxWorkspaces,
-            current: usage.workspaceCount,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * Check if user can add a new repo
- */
-export async function canAddRepo(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);
-    const usage = await getUserUsage(userId);
-    if (usage.repoCount >= limits.maxRepos) {
-        return {
-            allowed: false,
-            reason: `Repository limit reached for ${plan} plan`,
-            limit: limits.maxRepos,
-            current: usage.repoCount,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * Check if user can spawn another agent (concurrent agent limit)
- */
-export async function canSpawnAgent(userId, currentRunningAgents) {
-    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);
-    // Use provided count or fetch from usage
-    let concurrentAgents;
-    if (currentRunningAgents !== undefined) {
-        concurrentAgents = currentRunningAgents;
-    }
-    else {
-        const usage = await getUserUsage(userId);
-        concurrentAgents = usage.concurrentAgents;
-    }
-    if (concurrentAgents >= limits.maxConcurrentAgents) {
-        return {
-            allowed: false,
-            reason: `Concurrent agent limit reached for ${plan} plan`,
-            limit: limits.maxConcurrentAgents,
-            current: concurrentAgents,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * Check if user can use coordinator agents
- */
-export async function canUseCoordinator(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.coordinatorsEnabled) {
-        return {
-            allowed: false,
-            reason: 'Coordinator agents require a Pro plan or higher',
-            requiredPlan: 'pro',
-        };
-    }
-    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
- */
-export async function hasComputeHoursAvailable(userId) {
-    const user = await db.users.findById(userId);
-    if (!user) {
-        return { available: false, reason: 'User not found' };
-    }
-    const plan = user.plan || 'free';
-    const limits = getPlanLimits(plan);
-    const usage = await getUserUsage(userId);
-    // Enterprise has unlimited
-    if (limits.maxComputeHoursPerMonth === Infinity) {
-        return { available: true };
-    }
-    if (usage.computeHoursThisMonth >= limits.maxComputeHoursPerMonth) {
-        return {
-            available: false,
-            reason: `Compute hours limit reached for ${plan} plan`,
-            limit: limits.maxComputeHoursPerMonth,
-            current: usage.computeHoursThisMonth,
-        };
-    }
-    return { available: true };
-}
-/**
- * Get remaining quota for a user
- */
-export async function getRemainingQuota(userId) {
-    const user = await db.users.findById(userId);
-    const plan = (user?.plan || 'free');
-    const limits = getPlanLimits(plan);
-    const usage = await getUserUsage(userId);
-    const calcRemaining = (limit, current) => limit === Infinity ? Infinity : Math.max(0, limit - current);
-    return {
-        plan,
-        limits,
-        usage,
-        remaining: {
-            workspaces: calcRemaining(limits.maxWorkspaces, usage.workspaceCount),
-            repos: calcRemaining(limits.maxRepos, usage.repoCount),
-            concurrentAgents: calcRemaining(limits.maxConcurrentAgents, usage.concurrentAgents),
-            computeHours: calcRemaining(limits.maxComputeHoursPerMonth, usage.computeHoursThisMonth),
-        },
-    };
-}
-/**
- * Record compute usage
- */
-export async function recordComputeUsage(userId, workspaceId, hours) {
-    const drizzleDb = getDb();
-    await drizzleDb.insert(usageRecordsTable).values({
-        userId,
-        workspaceId,
-        metric: 'compute_hours',
-        value: Math.round(hours * 100) / 100, // Round to 2 decimal places
-        recordedAt: new Date(),
-    });
-}
-/**
- * Update active agent count for a user
- */
-export async function updateActiveAgentCount(userId, workspaceId, count) {
-    const drizzleDb = getDb();
-    await drizzleDb.insert(usageRecordsTable).values({
-        userId,
-        workspaceId,
-        metric: 'active_agents',
-        value: 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