agent-relay 2.0.22 → 2.0.24

package/packages/cloud/dist/billing/service.js

@@ -1,388 +0,0 @@
-/**
- * Agent Relay Cloud - Billing Service
- *
- * Stripe integration for subscription management, payments, and webhooks.
- */
-import Stripe from 'stripe';
-import { getConfig } from '../config.js';
-import { getPlan } from './plans.js';
-let stripeClient = null;
-/**
- * Get or create Stripe client
- */
-function getStripe() {
-    if (!stripeClient) {
-        const config = getConfig();
-        stripeClient = new Stripe(config.stripe.secretKey);
-    }
-    return stripeClient;
-}
-/**
- * Billing Service
- */
-export class BillingService {
-    stripe;
-    constructor() {
-        this.stripe = getStripe();
-    }
-    /**
-     * Create or get a Stripe customer for a user
-     */
-    async getOrCreateCustomer(userId, email, name) {
-        // Search for existing customer by metadata
-        const existing = await this.stripe.customers.search({
-            query: `metadata['user_id']:'${userId}'`,
-            limit: 1,
-        });
-        if (existing.data.length > 0) {
-            return existing.data[0].id;
-        }
-        // Create new customer
-        const customer = await this.stripe.customers.create({
-            email,
-            name,
-            metadata: {
-                user_id: userId,
-            },
-        });
-        return customer.id;
-    }
-    /**
-     * Get customer details including subscription
-     */
-    async getCustomer(stripeCustomerId) {
-        try {
-            const customer = await this.stripe.customers.retrieve(stripeCustomerId, {
-                expand: ['subscriptions', 'invoice_settings.default_payment_method'],
-            });
-            if (customer.deleted) {
-                return null;
-            }
-            // Get payment methods
-            const paymentMethods = await this.stripe.paymentMethods.list({
-                customer: stripeCustomerId,
-                type: 'card',
-            });
-            // Get recent invoices
-            const invoices = await this.stripe.invoices.list({
-                customer: stripeCustomerId,
-                limit: 10,
-            });
-            const subscription = customer.subscriptions?.data[0];
-            return {
-                id: customer.metadata?.user_id || '',
-                stripeCustomerId,
-                email: customer.email || '',
-                name: customer.name || undefined,
-                subscription: subscription ? this.mapSubscription(subscription) : undefined,
-                paymentMethods: paymentMethods.data.map((pm) => this.mapPaymentMethod(pm)),
-                invoices: invoices.data.map((inv) => this.mapInvoice(inv)),
-                createdAt: new Date(customer.created * 1000),
-                updatedAt: new Date(),
-            };
-        }
-        catch (error) {
-            if (error.code === 'resource_missing') {
-                return null;
-            }
-            throw error;
-        }
-    }
-    /**
-     * Create a checkout session for subscription
-     */
-    async createCheckoutSession(customerId, tier, billingInterval, successUrl, cancelUrl) {
-        const config = getConfig();
-        // Validate tier exists
-        getPlan(tier);
-        // Get the appropriate price ID
-        let priceId;
-        if (billingInterval === 'month') {
-            priceId = config.stripe.priceIds[`${tier}Monthly`];
-        }
-        else {
-            priceId = config.stripe.priceIds[`${tier}Yearly`];
-        }
-        if (!priceId) {
-            throw new Error(`No price configured for ${tier} ${billingInterval}ly plan`);
-        }
-        const session = await this.stripe.checkout.sessions.create({
-            customer: customerId,
-            payment_method_types: ['card'],
-            mode: 'subscription',
-            line_items: [
-                {
-                    price: priceId,
-                    quantity: 1,
-                },
-            ],
-            success_url: successUrl,
-            cancel_url: cancelUrl,
-            subscription_data: {
-                metadata: {
-                    tier,
-                },
-            },
-            allow_promotion_codes: true,
-        });
-        return {
-            sessionId: session.id,
-            url: session.url,
-        };
-    }
-    /**
-     * Create a billing portal session for managing subscription
-     */
-    async createPortalSession(customerId, returnUrl) {
-        const session = await this.stripe.billingPortal.sessions.create({
-            customer: customerId,
-            return_url: returnUrl,
-        });
-        return {
-            url: session.url,
-        };
-    }
-    /**
-     * Change subscription tier
-     */
-    async changeSubscription(subscriptionId, newTier, billingInterval) {
-        const config = getConfig();
-        // Get new price ID
-        let priceId;
-        if (billingInterval === 'month') {
-            priceId = config.stripe.priceIds[`${newTier}Monthly`];
-        }
-        else {
-            priceId = config.stripe.priceIds[`${newTier}Yearly`];
-        }
-        if (!priceId) {
-            throw new Error(`No price configured for ${newTier} ${billingInterval}ly plan`);
-        }
-        // Get current subscription
-        const subscription = await this.stripe.subscriptions.retrieve(subscriptionId);
-        const currentItem = subscription.items.data[0];
-        // Update subscription
-        const updated = await this.stripe.subscriptions.update(subscriptionId, {
-            items: [
-                {
-                    id: currentItem.id,
-                    price: priceId,
-                },
-            ],
-            metadata: {
-                tier: newTier,
-            },
-            proration_behavior: 'create_prorations',
-        });
-        return this.mapSubscription(updated);
-    }
-    /**
-     * Cancel subscription at period end
-     */
-    async cancelSubscription(subscriptionId) {
-        const subscription = await this.stripe.subscriptions.update(subscriptionId, {
-            cancel_at_period_end: true,
-        });
-        return this.mapSubscription(subscription);
-    }
-    /**
-     * Resume a canceled subscription
-     */
-    async resumeSubscription(subscriptionId) {
-        const subscription = await this.stripe.subscriptions.update(subscriptionId, {
-            cancel_at_period_end: false,
-        });
-        return this.mapSubscription(subscription);
-    }
-    /**
-     * Add a payment method to customer
-     */
-    async addPaymentMethod(customerId, paymentMethodId, setAsDefault = false) {
-        // Attach payment method to customer
-        const pm = await this.stripe.paymentMethods.attach(paymentMethodId, {
-            customer: customerId,
-        });
-        // Set as default if requested
-        if (setAsDefault) {
-            await this.stripe.customers.update(customerId, {
-                invoice_settings: {
-                    default_payment_method: paymentMethodId,
-                },
-            });
-        }
-        return this.mapPaymentMethod(pm, setAsDefault);
-    }
-    /**
-     * Remove a payment method
-     */
-    async removePaymentMethod(paymentMethodId) {
-        await this.stripe.paymentMethods.detach(paymentMethodId);
-    }
-    /**
-     * Set default payment method
-     */
-    async setDefaultPaymentMethod(customerId, paymentMethodId) {
-        await this.stripe.customers.update(customerId, {
-            invoice_settings: {
-                default_payment_method: paymentMethodId,
-            },
-        });
-    }
-    /**
-     * Get upcoming invoice preview
-     */
-    async getUpcomingInvoice(customerId) {
-        try {
-            const invoice = await this.stripe.invoices.retrieveUpcoming({
-                customer: customerId,
-            });
-            return this.mapInvoice(invoice);
-        }
-        catch (error) {
-            if (error.code === 'invoice_upcoming_none') {
-                return null;
-            }
-            throw error;
-        }
-    }
-    /**
-     * Record usage for metered billing
-     */
-    async recordUsage(subscriptionItemId, quantity, timestamp) {
-        await this.stripe.subscriptionItems.createUsageRecord(subscriptionItemId, {
-            quantity,
-            timestamp: timestamp ? Math.floor(timestamp.getTime() / 1000) : undefined,
-            action: 'increment',
-        });
-    }
-    /**
-     * Verify webhook signature
-     */
-    verifyWebhookSignature(payload, signature) {
-        const config = getConfig();
-        return this.stripe.webhooks.constructEvent(payload, signature, config.stripe.webhookSecret);
-    }
-    /**
-     * Process webhook event
-     */
-    async processWebhookEvent(event) {
-        const billingEvent = {
-            id: event.id,
-            type: this.mapEventType(event.type),
-            stripeEventId: event.id,
-            data: event.data.object,
-            createdAt: new Date(event.created * 1000),
-        };
-        // Extract user ID from customer metadata if available
-        if ('customer' in event.data.object) {
-            const customerId = event.data.object.customer;
-            if (customerId) {
-                try {
-                    const customer = await this.stripe.customers.retrieve(customerId);
-                    if (!customer.deleted && customer.metadata?.user_id) {
-                        billingEvent.userId = customer.metadata.user_id;
-                    }
-                }
-                catch {
-                    // Customer not found, continue without user ID
-                }
-            }
-        }
-        billingEvent.processedAt = new Date();
-        return billingEvent;
-    }
-    /**
-     * Get subscription tier from Stripe subscription
-     */
-    getTierFromSubscription(subscription) {
-        // Check metadata first
-        if (subscription.metadata?.tier) {
-            return subscription.metadata.tier;
-        }
-        // Fallback: determine from price ID
-        const config = getConfig();
-        const priceId = subscription.items.data[0]?.price.id;
-        for (const [key, value] of Object.entries(config.stripe.priceIds)) {
-            if (value === priceId) {
-                // Extract tier from key (e.g., 'proMonthly' -> 'pro')
-                return key.replace(/(Monthly|Yearly)$/, '').toLowerCase();
-            }
-        }
-        return 'free'; // Default fallback
-    }
-    // Helper: Map Stripe subscription to our type
-    mapSubscription(subscription) {
-        const sub = subscription;
-        return {
-            id: subscription.id,
-            stripeSubscriptionId: subscription.id,
-            tier: this.getTierFromSubscription(subscription),
-            status: subscription.status,
-            currentPeriodStart: new Date((sub.current_period_start || sub.billing_cycle_anchor) * 1000),
-            currentPeriodEnd: new Date((sub.current_period_end || sub.current_period_start + 30 * 24 * 60 * 60) * 1000),
-            cancelAtPeriodEnd: subscription.cancel_at_period_end,
-            billingInterval: subscription.items.data[0]?.price.recurring?.interval === 'year'
-                ? 'year'
-                : 'month',
-            createdAt: new Date(subscription.created * 1000),
-        };
-    }
-    // Helper: Map Stripe payment method to our type
-    mapPaymentMethod(pm, isDefault = false) {
-        return {
-            id: pm.id,
-            stripePaymentMethodId: pm.id,
-            type: pm.type,
-            isDefault,
-            card: pm.card
-                ? {
-                    brand: pm.card.brand,
-                    last4: pm.card.last4,
-                    expMonth: pm.card.exp_month,
-                    expYear: pm.card.exp_year,
-                }
-                : undefined,
-        };
-    }
-    // Helper: Map Stripe invoice to our type
-    mapInvoice(invoice) {
-        const isUpcoming = !('id' in invoice) || invoice.id === null;
-        return {
-            id: isUpcoming ? 'upcoming' : invoice.id,
-            stripeInvoiceId: isUpcoming ? 'upcoming' : invoice.id,
-            amountDue: invoice.amount_due,
-            amountPaid: invoice.amount_paid,
-            status: isUpcoming ? 'draft' : invoice.status,
-            invoicePdf: 'invoice_pdf' in invoice ? invoice.invoice_pdf ?? undefined : undefined,
-            hostedInvoiceUrl: 'hosted_invoice_url' in invoice ? invoice.hosted_invoice_url ?? undefined : undefined,
-            periodStart: new Date(invoice.period_start * 1000),
-            periodEnd: new Date(invoice.period_end * 1000),
-            createdAt: new Date((invoice.created || Date.now() / 1000) * 1000),
-        };
-    }
-    // Helper: Map Stripe event type to our type
-    mapEventType(stripeType) {
-        const mapping = {
-            'customer.subscription.created': 'subscription.created',
-            'customer.subscription.updated': 'subscription.updated',
-            'customer.subscription.deleted': 'subscription.canceled',
-            'customer.subscription.trial_will_end': 'subscription.trial_ending',
-            'invoice.paid': 'invoice.paid',
-            'invoice.payment_failed': 'invoice.payment_failed',
-            'payment_method.attached': 'payment_method.attached',
-            'payment_method.detached': 'payment_method.detached',
-            'customer.created': 'customer.created',
-            'customer.updated': 'customer.updated',
-        };
-        return mapping[stripeType] || 'customer.updated';
-    }
-}
-// Export singleton instance
-let billingService = null;
-export function getBillingService() {
-    if (!billingService) {
-        billingService = new BillingService();
-    }
-    return billingService;
-}
-//# sourceMappingURL=service.js.map

package/packages/cloud/dist/billing/types.d.ts

@@ -1,141 +0,0 @@
-/**
- * Agent Relay Cloud - Billing Types
- *
- * Defines subscription plans, customer data, and billing events.
- */
-/**
- * Subscription tier levels
- */
-export type SubscriptionTier = 'free' | 'pro' | 'team' | 'enterprise';
-/**
- * Plan definitions with limits and pricing
- */
-export interface BillingPlan {
-    id: SubscriptionTier;
-    name: string;
-    description: string;
-    priceMonthly: number;
-    priceYearly: number;
-    stripePriceIdMonthly?: string;
-    stripePriceIdYearly?: string;
-    limits: BillingPlanLimits;
-    features: string[];
-}
-/**
- * Resource limits per plan for billing/display purposes.
- * These limits are shown to customers on pricing pages and in account settings.
- *
- * Note: For runtime limit checking (API enforcement), use PlanLimits from
- * src/cloud/services/planLimits.ts which has a focused subset of limits.
- */
-export interface BillingPlanLimits {
-    maxWorkspaces: number;
-    maxAgentsPerWorkspace: number;
-    maxTeamMembers: number;
-    maxStorageGB: number;
-    maxComputeHoursPerMonth: number;
-    customDomains: boolean;
-    prioritySupport: boolean;
-    sla: boolean;
-    ssoEnabled: boolean;
-    auditLogs: boolean;
-    /** Cloud session persistence (summaries, session tracking) - Pro+ only */
-    sessionPersistence: boolean;
-}
-/**
- * Customer billing information
- */
-export interface BillingCustomer {
-    id: string;
-    stripeCustomerId: string;
-    email: string;
-    name?: string;
-    subscription?: CustomerSubscription;
-    paymentMethods: PaymentMethod[];
-    invoices: Invoice[];
-    createdAt: Date;
-    updatedAt: Date;
-}
-/**
- * Active subscription
- */
-export interface CustomerSubscription {
-    id: string;
-    stripeSubscriptionId: string;
-    tier: SubscriptionTier;
-    status: SubscriptionStatus;
-    currentPeriodStart: Date;
-    currentPeriodEnd: Date;
-    cancelAtPeriodEnd: boolean;
-    billingInterval: 'month' | 'year';
-    createdAt: Date;
-}
-export type SubscriptionStatus = 'active' | 'past_due' | 'canceled' | 'incomplete' | 'trialing' | 'unpaid';
-/**
- * Payment method
- */
-export interface PaymentMethod {
-    id: string;
-    stripePaymentMethodId: string;
-    type: 'card' | 'us_bank_account' | 'sepa_debit';
-    isDefault: boolean;
-    card?: {
-        brand: string;
-        last4: string;
-        expMonth: number;
-        expYear: number;
-    };
-}
-/**
- * Invoice
- */
-export interface Invoice {
-    id: string;
-    stripeInvoiceId: string;
-    amountDue: number;
-    amountPaid: number;
-    status: 'draft' | 'open' | 'paid' | 'void' | 'uncollectible';
-    invoicePdf?: string;
-    hostedInvoiceUrl?: string;
-    periodStart: Date;
-    periodEnd: Date;
-    createdAt: Date;
-}
-/**
- * Usage record for metered billing
- */
-export interface UsageRecord {
-    userId: string;
-    workspaceId: string;
-    metric: UsageMetric;
-    quantity: number;
-    timestamp: Date;
-}
-export type UsageMetric = 'compute_hours' | 'storage_gb' | 'api_calls' | 'agent_spawns';
-/**
- * Billing event for webhooks and audit
- */
-export interface BillingEvent {
-    id: string;
-    type: BillingEventType;
-    userId?: string;
-    stripeEventId?: string;
-    data: Record<string, unknown>;
-    processedAt?: Date;
-    createdAt: Date;
-}
-export type BillingEventType = 'subscription.created' | 'subscription.updated' | 'subscription.canceled' | 'subscription.trial_ending' | 'invoice.paid' | 'invoice.payment_failed' | 'payment_method.attached' | 'payment_method.detached' | 'customer.created' | 'customer.updated';
-/**
- * Checkout session result
- */
-export interface CheckoutSession {
-    sessionId: string;
-    url: string;
-}
-/**
- * Portal session for managing subscription
- */
-export interface PortalSession {
-    url: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/packages/cloud/dist/billing/types.js

@@ -1,7 +0,0 @@
-/**
- * Agent Relay Cloud - Billing Types
- *
- * Defines subscription plans, customer data, and billing events.
- */
-export {};
-//# sourceMappingURL=types.js.map

package/packages/cloud/dist/config.d.ts

@@ -1,5 +0,0 @@
-/**
- * @deprecated Import from '@agent-relay/config/cloud-config' instead.
- */
-export * from '@agent-relay/config/cloud-config';
-//# sourceMappingURL=config.d.ts.map

package/packages/cloud/dist/config.js

@@ -1,5 +0,0 @@
-/**
- * @deprecated Import from '@agent-relay/config/cloud-config' instead.
- */
-export * from '@agent-relay/config/cloud-config';
-//# sourceMappingURL=config.js.map

package/packages/cloud/dist/db/bulk-ingest.d.ts

@@ -1,89 +0,0 @@
-/**
- * Bulk Ingest Utilities
- *
- * Optimized bulk insert operations for high-volume message sync.
- * Uses raw SQL for performance instead of ORM-generated queries.
- *
- * Key optimizations:
- * - Multi-row INSERT with VALUES for batches
- * - Streaming COPY for very large batches (>1000 rows)
- * - Proper JSONB serialization
- * - Connection reuse via pool
- * - Chunk processing for memory efficiency
- */
-import { Pool } from 'pg';
-type NewAgentMessage = Record<string, unknown>;
-export interface PoolConfig {
-    connectionString: string;
-    /** Maximum number of connections in pool (default: 20) */
-    max?: number;
-    /** How long a client can be idle before being closed (default: 30000) */
-    idleTimeoutMillis?: number;
-    /** Max time to wait for a connection (default: 10000) */
-    connectionTimeoutMillis?: number;
-    /** Enable SSL (default: based on connection string) */
-    ssl?: boolean | {
-        rejectUnauthorized: boolean;
-    };
-}
-export declare const DEFAULT_POOL_CONFIG: Partial<PoolConfig>;
-/**
- * Result of a bulk insert operation
- */
-export interface BulkInsertResult {
-    inserted: number;
-    duplicates: number;
-    errors: number;
-    durationMs: number;
-}
-/**
- * Bulk insert messages using optimized multi-row INSERT.
- *
- * Uses ON CONFLICT DO NOTHING for deduplication.
- * Much faster than individual inserts for batches.
- *
- * @param pool Database connection pool
- * @param messages Messages to insert
- * @param chunkSize Number of rows per INSERT statement (default: 100)
- */
-export declare function bulkInsertMessages(pool: Pool, messages: NewAgentMessage[], chunkSize?: number): Promise<BulkInsertResult>;
-/**
- * Streaming bulk insert using staging table for very large batches.
- *
- * Uses chunked multi-row INSERT into a temp staging table,
- * then a single INSERT SELECT for deduplication.
- * This avoids holding all data in memory and is efficient for large batches.
- *
- * @param pool Database connection pool
- * @param messages Messages to insert
- */
-export declare function streamingBulkInsert(pool: Pool, messages: NewAgentMessage[]): Promise<BulkInsertResult>;
-/**
- * Optimized bulk insert that chooses strategy based on batch size.
- *
- * - Small batches (<100): Use regular ORM insert
- * - Medium batches (100-1000): Use multi-row INSERT
- * - Large batches (>1000): Use streaming COPY
- *
- * @param pool Database connection pool
- * @param messages Messages to insert
- */
-export declare function optimizedBulkInsert(pool: Pool, messages: NewAgentMessage[]): Promise<BulkInsertResult>;
-/**
- * Get pool statistics for monitoring.
- */
-export declare function getPoolStats(pool: Pool): {
-    total: number;
-    idle: number;
-    waiting: number;
-};
-/**
- * Health check for the connection pool.
- */
-export declare function checkPoolHealth(pool: Pool): Promise<{
-    healthy: boolean;
-    latencyMs: number;
-    error?: string;
-}>;
-export {};
-//# sourceMappingURL=bulk-ingest.d.ts.map