fraim 2.0.177 → 2.0.180

package/dist/src/api/payment/webhook.js

@@ -0,0 +1,587 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDashboardAccessUrl = void 0;
+exports.handleStripeWebhook = handleStripeWebhook;
+exports.resolveSubscriptionNextBillingDate = resolveSubscriptionNextBillingDate;
+exports.isInitialSubscriptionInvoice = isInitialSubscriptionInvoice;
+exports.getInvoiceAmountPaidCents = getInvoiceAmountPaidCents;
+exports.extractSubscriptionPeriodEndDate = extractSubscriptionPeriodEndDate;
+exports.extractInvoicePeriodEndDate = extractInvoicePeriodEndDate;
+exports.resolveSubscriptionNextBillingDateWithInvoiceFallback = resolveSubscriptionNextBillingDateWithInvoiceFallback;
+exports.buildCurrentPeriodEndUpdate = buildCurrentPeriodEndUpdate;
+exports.resolveInvoicePaidNextBillingDate = resolveInvoicePaidNextBillingDate;
+const stripe_1 = require("../../config/stripe");
+const feature_flags_1 = require("../../config/feature-flags");
+const email_service_1 = require("../../services/email-service");
+const dashboard_access_1 = require("../../services/dashboard-access");
+Object.defineProperty(exports, "createDashboardAccessUrl", { enumerable: true, get: function () { return dashboard_access_1.createDashboardAccessUrl; } });
+const persona_entitlement_service_1 = require("../../services/persona-entitlement-service");
+async function handleStripeWebhook(req, res, paymentRepo, dbService) {
+    const sig = req.headers['stripe-signature'];
+    if (!sig) {
+        return res.status(400).json({ error: 'Missing stripe-signature header' });
+    }
+    let event;
+    try {
+        // When using express.raw(), req.body is a Buffer
+        // When using express.json(), req.body is an object
+        const rawBody = Buffer.isBuffer(req.body)
+            ? req.body
+            : (typeof req.body === 'string' ? req.body : JSON.stringify(req.body));
+        // Verify webhook signature
+        event = stripe_1.stripe.webhooks.constructEvent(rawBody, sig, stripe_1.STRIPE_CONFIG.webhookSecret);
+    }
+    catch (err) {
+        console.error('❌ Webhook signature verification failed:', err.message);
+        return res.status(400).json({ error: `Webhook Error: ${err.message}` });
+    }
+    console.log(`✅ Webhook received: ${event.type} (id: ${event.id})`);
+    // Check for idempotency if dbService available
+    if (dbService) {
+        try {
+            const alreadyProcessed = await dbService.isWebhookEventProcessed(event.id);
+            if (alreadyProcessed) {
+                console.log(`ℹ️ Webhook ${event.id} already processed, skipping`);
+                return res.json({ received: true, skipped: true });
+            }
+            // Record webhook event
+            await dbService.recordWebhookEvent({
+                eventId: event.id,
+                type: event.type,
+                processed: false,
+                processedAt: null,
+                receivedAt: new Date(),
+                retryCount: 0,
+                lastError: null
+            });
+        }
+        catch (error) {
+            if (error.message === 'Webhook event already processed') {
+                console.log(`ℹ️ Webhook ${event.id} already processed (race condition), skipping`);
+                return res.json({ received: true, skipped: true });
+            }
+            console.error('❌ Error recording webhook event:', error);
+            // Continue processing even if recording fails
+        }
+    }
+    try {
+        switch (event.type) {
+            // Subscription lifecycle events
+            case 'customer.subscription.created':
+            case 'customer.subscription.updated': {
+                const subscription = event.data.object;
+                if (dbService) {
+                    await handleSubscriptionCreatedOrUpdated(subscription, dbService);
+                }
+                break;
+            }
+            case 'customer.subscription.deleted': {
+                const subscription = event.data.object;
+                if (dbService) {
+                    await handleSubscriptionDeleted(subscription, dbService);
+                }
+                break;
+            }
+            case 'invoice.paid': {
+                const invoice = event.data.object;
+                if (dbService) {
+                    await handleInvoicePaid(invoice, dbService);
+                }
+                break;
+            }
+            case 'invoice.payment_failed': {
+                const invoice = event.data.object;
+                if (dbService) {
+                    await handleInvoicePaymentFailed(invoice, dbService);
+                }
+                break;
+            }
+            // Legacy payment events (for one-time payments)
+            case 'checkout.session.completed': {
+                const session = event.data.object;
+                await handleCheckoutSessionCompleted(session, paymentRepo, dbService);
+                break;
+            }
+            case 'payment_intent.succeeded': {
+                const paymentIntent = event.data.object;
+                await handlePaymentSuccess(paymentIntent, paymentRepo);
+                break;
+            }
+            case 'payment_intent.payment_failed': {
+                const paymentIntent = event.data.object;
+                await handlePaymentFailure(paymentIntent, paymentRepo);
+                break;
+            }
+            default:
+                console.log(`ℹ️ Unhandled event type: ${event.type}`);
+        }
+        // Mark event as processed
+        if (dbService) {
+            await dbService.markWebhookEventProcessed(event.id);
+        }
+        res.json({ received: true });
+    }
+    catch (error) {
+        console.error('❌ Error processing webhook:', error);
+        // Mark event as failed
+        if (dbService) {
+            await dbService.markWebhookEventFailed(event.id, error.message);
+        }
+        res.status(500).json({ error: 'Webhook processing failed', details: error.message });
+    }
+}
+// ========== Subscription Lifecycle Handlers ==========
+async function resolveSubscriptionNextBillingDate(subscription, subscriptionRetriever = (subscriptionId) => stripe_1.stripe.subscriptions.retrieve(subscriptionId)) {
+    const directPeriodEnd = extractSubscriptionPeriodEndDate(subscription);
+    if (directPeriodEnd) {
+        return directPeriodEnd;
+    }
+    if (!subscription.id) {
+        return null;
+    }
+    try {
+        const fetchedSubscription = await subscriptionRetriever(subscription.id);
+        const fetchedPeriodEnd = extractSubscriptionPeriodEndDate(fetchedSubscription);
+        if (fetchedPeriodEnd) {
+            return fetchedPeriodEnd;
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️ Failed to retrieve subscription ${subscription.id} for period end: ${error?.message || error}`);
+    }
+    return null;
+}
+function isInitialSubscriptionInvoice(invoice) {
+    return invoice.billing_reason === 'subscription_create';
+}
+function getInvoiceAmountPaidCents(invoice) {
+    return typeof invoice.amount_paid === 'number' ? Math.max(0, invoice.amount_paid) : null;
+}
+function extractSubscriptionPeriodEndDate(subscription) {
+    const rootPeriodEnd = subscription.current_period_end;
+    if (typeof rootPeriodEnd === 'number' && rootPeriodEnd > 0) {
+        return new Date(rootPeriodEnd * 1000);
+    }
+    const itemEnds = (subscription.items?.data || [])
+        .map((item) => item?.current_period_end)
+        .filter((value) => typeof value === 'number' && value > 0);
+    if (itemEnds.length > 0) {
+        // Use the earliest upcoming period boundary across items.
+        return new Date(Math.min(...itemEnds) * 1000);
+    }
+    return null;
+}
+function extractInvoicePeriodEndDate(invoice) {
+    const rootPeriodEnd = invoice.period_end;
+    if (typeof rootPeriodEnd === 'number' && rootPeriodEnd > 0) {
+        return new Date(rootPeriodEnd * 1000);
+    }
+    const linePeriodEnds = (invoice.lines?.data || [])
+        .map((line) => line?.period?.end)
+        .filter((value) => typeof value === 'number' && value > 0);
+    if (linePeriodEnds.length > 0) {
+        // Use the furthest period end across recurring/proration lines.
+        return new Date(Math.max(...linePeriodEnds) * 1000);
+    }
+    return null;
+}
+async function resolveSubscriptionNextBillingDateWithInvoiceFallback(subscription, subscriptionRetriever = (subscriptionId) => stripe_1.stripe.subscriptions.retrieve(subscriptionId), invoiceRetriever = (invoiceId) => stripe_1.stripe.invoices.retrieve(invoiceId)) {
+    const subscriptionDate = await resolveSubscriptionNextBillingDate(subscription, subscriptionRetriever);
+    if (subscriptionDate)
+        return subscriptionDate;
+    const latestInvoiceField = subscription.latest_invoice;
+    if (latestInvoiceField && typeof latestInvoiceField === 'object') {
+        const invoiceDate = extractInvoicePeriodEndDate(latestInvoiceField);
+        if (invoiceDate)
+            return invoiceDate;
+    }
+    if (typeof latestInvoiceField === 'string' && latestInvoiceField) {
+        try {
+            const latestInvoice = await invoiceRetriever(latestInvoiceField);
+            const invoiceDate = extractInvoicePeriodEndDate(latestInvoice);
+            if (invoiceDate)
+                return invoiceDate;
+        }
+        catch (error) {
+            console.warn(`⚠️ Failed to retrieve latest invoice ${latestInvoiceField} for subscription ${subscription.id}: ${error?.message || error}`);
+        }
+    }
+    return null;
+}
+function buildCurrentPeriodEndUpdate(nextBillingDate) {
+    return nextBillingDate ? { currentPeriodEnd: nextBillingDate } : {};
+}
+async function resolveInvoicePaidNextBillingDate(invoice, subscription, subscriptionDateResolver = resolveSubscriptionNextBillingDate) {
+    const subscriptionDate = subscription ? await subscriptionDateResolver(subscription) : null;
+    return subscriptionDate || extractInvoicePeriodEndDate(invoice);
+}
+function extractFounderDiscountFlagFromSubscription(subscription) {
+    return subscription.metadata?.founderDiscount === 'true';
+}
+async function handleSubscriptionCreatedOrUpdated(subscription, dbService) {
+    console.log(`✅ Subscription ${subscription.status}: ${subscription.id}`);
+    if (subscription.metadata?.plan === 'persona-hire') {
+        if ((0, feature_flags_1.isPersonaEntitlementsEnabled)()) {
+            const customerId = typeof subscription.customer === 'string'
+                ? subscription.customer
+                : subscription.customer.id;
+            const customer = await stripe_1.stripe.customers.retrieve(customerId);
+            const email = !('deleted' in customer) ? customer.email : null;
+            if (email && subscription.metadata.personaKey && (subscription.metadata.hireMode === 'job' || subscription.metadata.hireMode === 'fulltime')) {
+                const nextBillingDate = await resolveSubscriptionNextBillingDateWithInvoiceFallback(subscription);
+                await (0, persona_entitlement_service_1.syncPersonaEntitlementPurchase)(dbService, {
+                    userId: email,
+                    stripeCustomerId: customerId,
+                    stripeSubscriptionId: subscription.id,
+                    stripeCheckoutSessionId: null,
+                    personaKey: subscription.metadata.personaKey,
+                    hireMode: subscription.metadata.hireMode,
+                    purchaseSource: 'stripe-webhook',
+                    status: subscription.status === 'active' ? 'active' : 'suspended',
+                    expiresAt: nextBillingDate,
+                    metadata: subscription.metadata
+                });
+            }
+        }
+        console.log(`ℹ️ Skipping API-key provisioning for persona hire subscription: ${subscription.id}`);
+        return;
+    }
+    const customerId = typeof subscription.customer === 'string'
+        ? subscription.customer
+        : subscription.customer.id;
+    // Get or create API key for this customer
+    let apiKey = await dbService.getApiKeyByStripeCustomerId(customerId);
+    if (!apiKey) {
+        // Check if subscription has customer email in metadata
+        const customer = await stripe_1.stripe.customers.retrieve(customerId);
+        const email = customer.email;
+        if (!email) {
+            console.error(`❌ No email found for customer ${customerId}`);
+            return;
+        }
+        // Check if user already has an API key (trial user upgrading)
+        apiKey = await dbService.getApiKeyByUserId(email);
+        const nextBillingDate = await resolveSubscriptionNextBillingDateWithInvoiceFallback(subscription);
+        if (apiKey) {
+            // Upgrade trial key to paid subscription
+            await dbService.updateApiKey(apiKey.key, {
+                tier: 'paid-subscription',
+                status: subscription.status === 'active' ? 'active' : 'suspended',
+                stripeCustomerId: customerId,
+                stripeSubscriptionId: subscription.id,
+                ...buildCurrentPeriodEndUpdate(nextBillingDate),
+                expiresAt: null, // Subscriptions don't have fixed expiration
+                cancelAt: subscription.cancel_at ? new Date(subscription.cancel_at * 1000) : null
+            });
+            console.log(`✅ Upgraded trial key to paid subscription: ${apiKey.key}`);
+        }
+        else {
+            // Create new API key for subscription (shouldn't happen in normal flow)
+            const newKey = dbService.generateApiKey(email, 'default');
+            await dbService.createApiKey({
+                key: newKey,
+                userId: email,
+                orgId: 'default',
+                tier: 'paid-subscription',
+                status: subscription.status === 'active' ? 'active' : 'suspended',
+                expiresAt: null,
+                stripeCustomerId: customerId,
+                stripeSubscriptionId: subscription.id,
+                currentPeriodEnd: nextBillingDate,
+                cancelAt: subscription.cancel_at ? new Date(subscription.cancel_at * 1000) : null,
+                suspendedAt: null,
+                suspensionReason: null,
+                lastUsedAt: null,
+                apiCallCount: 0,
+                personaSystemActive: (0, feature_flags_1.isPersonaEntitlementsEnabled)() || undefined
+            });
+            console.log(`✅ Created new API key for subscription: ${newKey}`);
+            apiKey = { key: newKey, userId: email };
+        }
+    }
+    else {
+        // Update existing subscription key
+        const nextBillingDate = await resolveSubscriptionNextBillingDateWithInvoiceFallback(subscription);
+        await dbService.updateApiKey(apiKey.key, {
+            tier: 'paid-subscription',
+            status: subscription.status === 'active' ? 'active' : 'suspended',
+            stripeCustomerId: customerId,
+            stripeSubscriptionId: subscription.id,
+            ...buildCurrentPeriodEndUpdate(nextBillingDate),
+            expiresAt: null,
+            cancelAt: subscription.cancel_at ? new Date(subscription.cancel_at * 1000) : null,
+            suspendedAt: subscription.status !== 'active' ? new Date() : null,
+            suspensionReason: subscription.status !== 'active' ? subscription.status : null
+        });
+    }
+    // Intentionally no activation email here.
+    // Billing-confirmed messaging is sent from invoice.paid for Stripe source-of-truth amounts.
+}
+async function handleSubscriptionDeleted(subscription, dbService) {
+    if (subscription.metadata?.plan === 'persona-hire' && (0, feature_flags_1.isPersonaEntitlementsEnabled)()) {
+        const customerId = typeof subscription.customer === 'string'
+            ? subscription.customer
+            : subscription.customer.id;
+        const customer = await stripe_1.stripe.customers.retrieve(customerId);
+        const email = !('deleted' in customer) ? customer.email : null;
+        if (email && subscription.metadata.personaKey && subscription.metadata.hireMode === 'fulltime') {
+            await (0, persona_entitlement_service_1.syncPersonaEntitlementPurchase)(dbService, {
+                userId: email,
+                stripeCustomerId: customerId,
+                stripeSubscriptionId: subscription.id,
+                stripeCheckoutSessionId: null,
+                personaKey: subscription.metadata.personaKey,
+                hireMode: 'fulltime',
+                purchaseSource: 'stripe-webhook',
+                status: 'expired',
+                expiresAt: new Date(),
+                metadata: subscription.metadata
+            });
+        }
+    }
+    console.log(`❌ Subscription cancelled: ${subscription.id}`);
+    if (subscription.metadata?.plan === 'persona-hire') {
+        console.log(`ℹ️ Skipping persona hire cancellation handling for subscription: ${subscription.id}`);
+        return;
+    }
+    const apiKey = await dbService.getApiKeyByStripeSubscriptionId(subscription.id);
+    if (!apiKey) {
+        console.warn(`⚠️ No API key found for subscription: ${subscription.id}`);
+        return;
+    }
+    // Mark key as expired
+    await dbService.updateApiKey(apiKey.key, {
+        status: 'expired',
+        expiresAt: new Date(), // Expired now
+        cancelAt: null
+    });
+    // Send cancellation email
+    const emailService = new email_service_1.EmailService();
+    await emailService.sendSubscriptionCancelled(apiKey.userId, new Date());
+    console.log(`✅ API key expired due to subscription cancellation: ${apiKey.key}`);
+}
+async function handleInvoicePaid(invoice, dbService) {
+    console.log(`✅ Invoice paid: ${invoice.id}`);
+    const subscriptionField = invoice.subscription;
+    if (!subscriptionField) {
+        console.log(`ℹ️ Invoice is not for a subscription, skipping`);
+        return;
+    }
+    const subscriptionId = typeof subscriptionField === 'string'
+        ? subscriptionField
+        : subscriptionField.id;
+    const customerId = typeof invoice.customer === 'string'
+        ? invoice.customer
+        : invoice.customer?.id;
+    let apiKey = await dbService.getApiKeyByStripeSubscriptionId(subscriptionId);
+    if (!apiKey && customerId) {
+        apiKey = await dbService.getApiKeyByStripeCustomerId(customerId);
+        if (apiKey) {
+            await dbService.updateApiKey(apiKey.key, { stripeSubscriptionId: subscriptionId });
+        }
+    }
+    if (!apiKey && (0, feature_flags_1.isPersonaEntitlementsEnabled)() && invoice.customer_email) {
+        try {
+            const subscription = await stripe_1.stripe.subscriptions.retrieve(subscriptionId);
+            if (subscription.metadata?.plan === 'persona-hire') {
+                apiKey = { userId: invoice.customer_email };
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Failed persona entitlement prefetch for invoice ${invoice.id}: ${error?.message || error}`);
+        }
+    }
+    if (!apiKey) {
+        console.warn(`⚠️ No API key found for subscription: ${subscriptionId}`);
+        return;
+    }
+    const isInitialSubscriptionCharge = isInitialSubscriptionInvoice(invoice);
+    const amountPaidCents = getInvoiceAmountPaidCents(invoice);
+    let subscriptionForInvoice = null;
+    try {
+        subscriptionForInvoice = await stripe_1.stripe.subscriptions.retrieve(subscriptionId);
+    }
+    catch (error) {
+        console.warn(`⚠️ Failed to retrieve subscription ${subscriptionId} during invoice.paid: ${error?.message || error}`);
+    }
+    if (subscriptionForInvoice?.metadata?.plan === 'persona-hire') {
+        if ((0, feature_flags_1.isPersonaEntitlementsEnabled)() && subscriptionForInvoice.metadata.personaKey && subscriptionForInvoice.metadata.hireMode === 'fulltime') {
+            const email = apiKey?.userId || invoice.customer_email;
+            if (email) {
+                await (0, persona_entitlement_service_1.syncPersonaEntitlementPurchase)(dbService, {
+                    userId: email,
+                    stripeCustomerId: customerId || null,
+                    stripeSubscriptionId: subscriptionId,
+                    stripeCheckoutSessionId: null,
+                    personaKey: subscriptionForInvoice.metadata.personaKey,
+                    hireMode: 'fulltime',
+                    purchaseSource: 'stripe-webhook',
+                    status: 'active',
+                    expiresAt: await resolveInvoicePaidNextBillingDate(invoice, subscriptionForInvoice),
+                    metadata: {
+                        ...subscriptionForInvoice.metadata,
+                        latestInvoiceId: invoice.id
+                    }
+                });
+            }
+        }
+        console.log(`ℹ️ Skipping API-key activation emails for persona hire subscription: ${subscriptionId}`);
+        return;
+    }
+    const nextBillingDate = await resolveInvoicePaidNextBillingDate(invoice, subscriptionForInvoice);
+    const currentPeriodPatch = buildCurrentPeriodEndUpdate(nextBillingDate);
+    // Restore key if it was suspended due to payment failure
+    if (apiKey.status === 'suspended') {
+        await dbService.updateApiKey(apiKey.key, {
+            status: 'active',
+            ...currentPeriodPatch,
+            suspendedAt: null,
+            suspensionReason: null
+        });
+        console.log(`✅ API key restored after payment: ${apiKey.key}`);
+        // Send restoration email
+        const emailService = new email_service_1.EmailService();
+        const restorationBillingDate = nextBillingDate || new Date();
+        await emailService.sendPaymentRestored(apiKey.userId, restorationBillingDate);
+        return;
+    }
+    if (isInitialSubscriptionCharge) {
+        // First paid subscription charge: send activation using Stripe invoice + subscription data
+        const emailService = new email_service_1.EmailService();
+        const subscription = subscriptionForInvoice || await stripe_1.stripe.subscriptions.retrieve(subscriptionId);
+        const activationBillingDate = nextBillingDate || await resolveSubscriptionNextBillingDate(subscription);
+        const billingCycle = subscription.items.data[0]?.price?.recurring?.interval === 'year' ? 'annual' : 'monthly';
+        const plan = subscription.items.data[0]?.price?.nickname ||
+            (subscription.metadata?.plan === 'managed' ? 'FRAIM Managed' : 'FRAIM Self-Serve');
+        const founderDiscount = extractFounderDiscountFlagFromSubscription(subscription);
+        if (activationBillingDate) {
+            await dbService.updateApiKey(apiKey.key, buildCurrentPeriodEndUpdate(activationBillingDate));
+        }
+        if (amountPaidCents === null || !activationBillingDate) {
+            console.warn(`⚠️ Skipping subscription activation email due to missing Stripe invoice/subscription data for ${subscriptionId}`);
+            return;
+        }
+        const dashboardUrl = await (0, dashboard_access_1.createDashboardAccessUrl)(dbService, apiKey.userId, apiKey.key);
+        await emailService.sendSubscriptionActivated(apiKey.userId, plan, amountPaidCents, billingCycle, activationBillingDate, dashboardUrl, founderDiscount);
+        return;
+    }
+    // Regular renewal
+    {
+        console.log(`✅ Subscription renewed: ${apiKey.key}`);
+        if (nextBillingDate) {
+            await dbService.updateApiKey(apiKey.key, buildCurrentPeriodEndUpdate(nextBillingDate));
+        }
+        // Send renewal receipt
+        const emailService = new email_service_1.EmailService();
+        const amount = (invoice.amount_paid || 0) / 100;
+        const renewalBillingDate = nextBillingDate || new Date();
+        await emailService.sendRenewalReceipt(apiKey.userId, amount, renewalBillingDate, invoice.hosted_invoice_url || undefined);
+    }
+}
+async function handleInvoicePaymentFailed(invoice, dbService) {
+    console.log(`❌ Invoice payment failed: ${invoice.id}`);
+    const subscriptionField = invoice.subscription;
+    if (!subscriptionField) {
+        console.log(`ℹ️ Invoice is not for a subscription, skipping`);
+        return;
+    }
+    const subscriptionId = typeof subscriptionField === 'string'
+        ? subscriptionField
+        : subscriptionField.id;
+    try {
+        const subscription = await stripe_1.stripe.subscriptions.retrieve(subscriptionId);
+        if (subscription.metadata?.plan === 'persona-hire') {
+            if ((0, feature_flags_1.isPersonaEntitlementsEnabled)()) {
+                const customerId = typeof subscription.customer === 'string'
+                    ? subscription.customer
+                    : subscription.customer.id;
+                const customer = await stripe_1.stripe.customers.retrieve(customerId);
+                const email = !('deleted' in customer) ? customer.email : null;
+                if (email && subscription.metadata.personaKey && subscription.metadata.hireMode === 'fulltime') {
+                    await (0, persona_entitlement_service_1.syncPersonaEntitlementPurchase)(dbService, {
+                        userId: email,
+                        stripeCustomerId: customerId,
+                        stripeSubscriptionId: subscriptionId,
+                        stripeCheckoutSessionId: null,
+                        personaKey: subscription.metadata.personaKey,
+                        hireMode: 'fulltime',
+                        purchaseSource: 'stripe-webhook',
+                        status: 'suspended',
+                        metadata: {
+                            ...subscription.metadata,
+                            latestFailedInvoiceId: invoice.id
+                        }
+                    });
+                }
+            }
+            console.log(`ℹ️ Skipping persona hire payment-failure handling for subscription: ${subscriptionId}`);
+            return;
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️ Failed to retrieve subscription ${subscriptionId} during invoice.payment_failed: ${error?.message || error}`);
+    }
+    const apiKey = await dbService.getApiKeyByStripeSubscriptionId(subscriptionId);
+    if (!apiKey) {
+        console.warn(`⚠️ No API key found for subscription: ${subscriptionId}`);
+        return;
+    }
+    // Suspend API key
+    await dbService.updateApiKey(apiKey.key, {
+        status: 'suspended',
+        suspendedAt: new Date(),
+        suspensionReason: 'payment_failed'
+    });
+    console.log(`✅ API key suspended due to payment failure: ${apiKey.key}`);
+    // Send payment failure email with 7-day grace period
+    const emailService = new email_service_1.EmailService();
+    const gracePeriodEndsAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000); // 7 days
+    const billingPortalUrl = process.env.STRIPE_BILLING_PORTAL_URL || 'https://fraimworks.ai/billing';
+    await emailService.sendPaymentFailed(apiKey.userId, billingPortalUrl, gracePeriodEndsAt);
+}
+// ========== Legacy Payment Handlers ==========
+async function handleCheckoutSessionCompleted(session, paymentRepo, dbService) {
+    if (dbService && (0, feature_flags_1.isPersonaEntitlementsEnabled)() && session.metadata?.plan === 'persona-hire') {
+        await (0, persona_entitlement_service_1.syncPersonaEntitlementFromCheckoutSession)(dbService, session, 'stripe-checkout');
+    }
+    console.log(`✅ Checkout session completed: ${session.id}`);
+    // Update payment record with payment intent ID
+    if (session.payment_intent) {
+        const paymentIntentId = typeof session.payment_intent === 'string'
+            ? session.payment_intent
+            : session.payment_intent.id;
+        // Find payment by checkout session ID and update with payment intent ID
+        const payment = await paymentRepo.getPaymentByStripePaymentIntent('');
+        // Note: This is a simplified approach. In production, you'd query by checkout session ID
+        // For now, we'll update in the payment_intent.succeeded handler
+    }
+}
+async function handlePaymentSuccess(paymentIntent, paymentRepo) {
+    console.log(`✅ Payment succeeded: ${paymentIntent.id}`);
+    // Update payment status
+    const updated = await paymentRepo.updatePaymentStatus(paymentIntent.id, 'succeeded', {
+        stripePaymentIntentId: paymentIntent.id,
+        completedAt: new Date(),
+    });
+    if (updated) {
+        console.log(`✅ Payment record updated: ${paymentIntent.id}`);
+        // TODO: Send confirmation email
+    }
+    else {
+        console.warn(`⚠️ Payment record not found for payment intent: ${paymentIntent.id}`);
+    }
+}
+async function handlePaymentFailure(paymentIntent, paymentRepo) {
+    console.log(`❌ Payment failed: ${paymentIntent.id}`);
+    // Update payment status
+    const updated = await paymentRepo.updatePaymentStatus(paymentIntent.id, 'failed', {
+        failureReason: paymentIntent.last_payment_error?.message || 'Unknown error',
+        failedAt: new Date(),
+    });
+    if (updated) {
+        console.log(`✅ Payment failure recorded: ${paymentIntent.id}`);
+    }
+    else {
+        console.warn(`⚠️ Payment record not found for payment intent: ${paymentIntent.id}`);
+    }
+}

package/dist/src/api/personas/me.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMyPersonas = getMyPersonas;
+const feature_flags_1 = require("../../config/feature-flags");
+const persona_entitlement_service_1 = require("../../services/persona-entitlement-service");
+async function getMyPersonas(req, res, dbService) {
+    try {
+        const apiKeyData = req.apiKeyData;
+        if (!apiKeyData?.userId) {
+            res.status(401).json({ error: 'Authentication required' });
+            return;
+        }
+        if (!(0, feature_flags_1.isPersonaEntitlementsEnabled)()) {
+            res.status(404).json({
+                error: 'Not found',
+                featureFlags: {
+                    personaEntitlements: false
+                }
+            });
+            return;
+        }
+        const state = await (0, persona_entitlement_service_1.getWorkspacePersonaState)(dbService, apiKeyData.userId, apiKeyData.key);
+        res.json(state);
+    }
+    catch (error) {
+        console.error('Error getting persona entitlements:', error);
+        res.status(500).json({ error: 'Failed to load persona entitlements', details: error?.message || String(error) });
+    }
+}

package/dist/src/api/pricing/get-config.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPricingConfig = getPricingConfig;
+const pricing_1 = require("../../config/pricing");
+const feature_flags_1 = require("../../config/feature-flags");
+/**
+ * GET /api/pricing/config
+ * Returns pricing configuration for frontend
+ */
+async function getPricingConfig(req, res) {
+    try {
+        res.json({
+            pricing: pricing_1.PRICING,
+            fixedFees: pricing_1.FIXED_FEES,
+            managedPricing: pricing_1.MANAGED_PRICING,
+            founderDiscountRate: pricing_1.FOUNDER_DISCOUNT_RATE,
+            consumerEmailDomains: pricing_1.CONSUMER_EMAIL_DOMAINS,
+            featureFlags: (0, feature_flags_1.getPublicFeatureFlags)(),
+        });
+    }
+    catch (error) {
+        console.error('Error getting pricing config:', error);
+        res.status(500).json({ error: 'Failed to get pricing configuration' });
+    }
+}