@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/server/routes/smart-search/types.d.ts

@@ -0,0 +1,81 @@
+export interface SearchIntent {
+    type: 'cars' | 'flights' | 'hotels' | 'rental' | 'restaurants' | 'products' | 'general';
+    query: string;
+    params: Record<string, string>;
+    /** Suggested domain sources for this intent — hints for result boosting, not filtering */
+    suggestedDomains?: string[];
+}
+export interface VerdictOption {
+    provider: string;
+    price: number;
+    currency: string;
+    route?: string;
+    url: string;
+    notes?: string;
+}
+export interface TransactionalVerdict {
+    /** Vertical / category — e.g. 'transit', 'gas', 'travel', 'equipment_rental' */
+    vertical: string;
+    /** Human-readable headline — e.g. "Cheapest I found is $19.00 on FlixBus for New York → Boston" */
+    headline: string;
+    /** How confident we are in the data (mirrors existing confidence field) */
+    confidence: 'HIGH' | 'MEDIUM' | 'LOW';
+    /** Best option found across all sources */
+    bestOption: VerdictOption;
+    /** Other options found, sorted cheapest-first */
+    alternatives: VerdictOption[];
+    /** Aggregate totals when applicable (round-trip, etc.) */
+    totals?: {
+        oneWayLowest?: number;
+        returnLowest?: number;
+        roundTripLowest?: number;
+        currency: string;
+    };
+    /** Caveats/disclaimers about the data */
+    caveats: string[];
+    /** Parsed query parameters (origin, destination, dates, etc.) */
+    query?: {
+        origin?: string;
+        destination?: string;
+        departDate?: string;
+        returnDate?: string;
+        isRoundTrip?: boolean;
+        mode?: string;
+    };
+}
+export interface SmartSearchResult {
+    type: 'cars' | 'flights' | 'hotels' | 'rental' | 'restaurants' | 'products' | 'general';
+    source: string;
+    sourceUrl: string;
+    content: string;
+    title?: string;
+    domainData?: any;
+    structured?: any;
+    results?: any[];
+    tokens: number;
+    fetchTimeMs: number;
+    loadingMessage?: string;
+    answer?: string;
+    confidence?: 'HIGH' | 'MEDIUM' | 'LOW';
+    sources?: Array<{
+        title: string;
+        url: string;
+        domain: string;
+    }>;
+    timing?: {
+        searchMs: number;
+        peelMs: number;
+        llmMs: number;
+    };
+    mapUrl?: string;
+    safety?: {
+        verified: boolean;
+        promptInjectionsBlocked: number;
+        maliciousPatternsStripped: number;
+        sourcesChecked: number;
+    };
+    /** Suggested authoritative domains for this query (financial → reuters, etc.) */
+    suggestedDomains?: string[];
+    /** Structured verdict for transactional queries (transit, gas, travel, etc.) */
+    verdict?: TransactionalVerdict;
+}

package/dist/server/routes/smart-search/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/routes/smart-search/utils.d.ts

@@ -0,0 +1,20 @@
+export type RequestedStore = {
+    id: 'amazon' | 'walmart' | 'bestbuy' | 'target' | 'ebay' | 'etsy' | 'traderjoes' | 'costco' | 'bjs' | 'dyson';
+    store: string;
+    domain: string;
+};
+export declare function detectRequestedStore(query: string): RequestedStore | null;
+export declare function stripRequestedStoreFromQuery(query: string, requestedStore?: RequestedStore | null): string;
+export declare function isRequestedStoreUrl(url: string, requestedStore?: RequestedStore | null): boolean;
+export declare function addAffiliateTag(url: string): string;
+export declare const SHOPPING_DOMAINS: Array<{
+    pattern: string;
+    name: string;
+}>;
+export declare function getStoreInfo(url: string): {
+    store: string;
+    domain: string;
+} | null;
+export declare function parsePrice(text: string): string | undefined;
+export declare function extractPriceValue(priceStr: string | undefined): number | undefined;
+export declare function cleanProductTitle(title: string): string;

package/dist/server/routes/smart-search/utils.js

@@ -0,0 +1,146 @@
+const AFFILIATE_TAGS = {
+    'amazon.com': { param: 'tag', value: process.env.AMAZON_AFFILIATE_TAG || '' },
+    'walmart.com': { param: 'wmlspartner', value: process.env.WALMART_AFFILIATE_ID || '' },
+    'bestbuy.com': { param: 'ref', value: process.env.BESTBUY_AFFILIATE_ID || '' },
+    'target.com': { param: 'afid', value: process.env.TARGET_AFFILIATE_ID || '' },
+    'ebay.com': { param: 'campid', value: process.env.EBAY_AFFILIATE_ID || '' },
+    'etsy.com': { param: 'ref', value: process.env.ETSY_AFFILIATE_ID || '' },
+    'booking.com': { param: 'aid', value: process.env.BOOKING_AFFILIATE_ID || '' },
+    'kayak.com': { param: 'affid', value: process.env.KAYAK_AFFILIATE_ID || '' },
+    'expedia.com': { param: 'affcid', value: process.env.EXPEDIA_AFFILIATE_ID || '' },
+};
+const DOMAIN_TO_STORE = {
+    'amazon.com': 'amazon', 'walmart.com': 'walmart', 'bestbuy.com': 'bestbuy',
+    'target.com': 'target', 'ebay.com': 'ebay', 'etsy.com': 'etsy',
+    'booking.com': 'booking', 'kayak.com': 'kayak', 'expedia.com': 'expedia',
+};
+const REQUESTED_STORES = [
+    { id: 'bestbuy', store: 'Best Buy', domain: 'bestbuy.com', patterns: [/\bbest[\s-]*buy(?:\.com)?\b/i] },
+    { id: 'walmart', store: 'Walmart', domain: 'walmart.com', patterns: [/\bwal(?:\s|-)?mart(?:\.com)?\b/i] },
+    { id: 'target', store: 'Target', domain: 'target.com', patterns: [/\btarget(?:\.com)?\b/i] },
+    { id: 'amazon', store: 'Amazon', domain: 'amazon.com', patterns: [/\bamazon(?:\.com)?\b/i] },
+    { id: 'costco', store: 'Costco', domain: 'costco.com', patterns: [/\bcostco(?:\.com)?\b/i] },
+    { id: 'bjs', store: "BJ's Wholesale Club", domain: 'bjs.com', patterns: [/\bbj'?s(?:\s+wholesale(?:\s+club)?)?(?:\.com)?\b/i] },
+    { id: 'traderjoes', store: "Trader Joe's", domain: 'traderjoes.com', patterns: [/\btrader\s+joe'?s(?:\.com)?\b/i] },
+    { id: 'dyson', store: 'Dyson', domain: 'dyson.com', patterns: [/\bdyson(?:\s+store|\.com)\b/i] },
+    { id: 'ebay', store: 'eBay', domain: 'ebay.com', patterns: [/\be(?:\s|-)?bay(?:\.com)?\b/i] },
+    { id: 'etsy', store: 'Etsy', domain: 'etsy.com', patterns: [/\betsy(?:\.com)?\b/i] },
+];
+export function detectRequestedStore(query) {
+    const normalized = query.toLowerCase();
+    for (const store of REQUESTED_STORES) {
+        if (store.patterns.some(pattern => pattern.test(normalized))) {
+            return { id: store.id, store: store.store, domain: store.domain };
+        }
+    }
+    return null;
+}
+export function stripRequestedStoreFromQuery(query, requestedStore) {
+    if (!query)
+        return query;
+    const stores = requestedStore
+        ? REQUESTED_STORES.filter(store => store.id === requestedStore.id)
+        : REQUESTED_STORES;
+    let stripped = query;
+    for (const store of stores) {
+        for (const pattern of store.patterns) {
+            const globalPattern = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`);
+            stripped = stripped.replace(globalPattern, ' ');
+        }
+    }
+    return stripped.replace(/\s+/g, ' ').trim();
+}
+export function isRequestedStoreUrl(url, requestedStore) {
+    if (!requestedStore)
+        return true;
+    try {
+        const hostname = new URL(url).hostname.replace(/^www\./, '');
+        return hostname === requestedStore.domain || hostname.endsWith(`.${requestedStore.domain}`);
+    }
+    catch {
+        return false;
+    }
+}
+export function addAffiliateTag(url) {
+    try {
+        const parsed = new URL(url);
+        const hostname = parsed.hostname.replace('www.', '');
+        for (const [domain] of Object.entries(DOMAIN_TO_STORE)) {
+            if ((hostname === domain || hostname.endsWith('.' + domain)) && AFFILIATE_TAGS[domain]?.value) {
+                const apiUrl = process.env.API_URL || 'https://api.webpeel.dev';
+                return `${apiUrl}/go?url=${encodeURIComponent(url)}`;
+            }
+        }
+    }
+    catch { /* invalid URL — return as-is */ }
+    return url;
+}
+export const SHOPPING_DOMAINS = [
+    { pattern: 'amazon.com', name: 'Amazon' }, { pattern: 'bestbuy.com', name: 'Best Buy' },
+    { pattern: 'walmart.com', name: 'Walmart' }, { pattern: 'target.com', name: 'Target' },
+    { pattern: 'costco.com', name: 'Costco' }, { pattern: 'bjs.com', name: "BJ's Wholesale Club" },
+    { pattern: 'traderjoes.com', name: "Trader Joe's" }, { pattern: 'dyson.com', name: 'Dyson' },
+    { pattern: 'zappos.com', name: 'Zappos' }, { pattern: 'rei.com', name: 'REI' },
+    { pattern: 'nordstrom.com', name: 'Nordstrom' }, { pattern: 'macys.com', name: "Macy's" },
+    { pattern: 'sephora.com', name: 'Sephora' }, { pattern: 'ulta.com', name: 'Ulta' },
+    { pattern: 'homedepot.com', name: 'Home Depot' }, { pattern: 'lowes.com', name: "Lowe's" },
+    { pattern: 'ebay.com', name: 'eBay' }, { pattern: 'etsy.com', name: 'Etsy' },
+    { pattern: 'tcgplayer.com', name: 'TCGPlayer' }, { pattern: 'cardmarket.com', name: 'Cardmarket' },
+    { pattern: 'mercari.com', name: 'Mercari' }, { pattern: 'facebook.com', name: 'Facebook Marketplace' },
+    { pattern: 'uline.com', name: 'Uline' }, { pattern: 'alibaba.com', name: 'Alibaba' },
+    { pattern: 'webstaurantstore.com', name: 'WebstaurantStore' }, { pattern: 'globalindustrial.com', name: 'Global Industrial' },
+    { pattern: 'staples.com', name: 'Staples' }, { pattern: 'instacart.com', name: 'Instacart' },
+    { pattern: 'freshdirect.com', name: 'FreshDirect' }, { pattern: 'wholefoodsmarket.com', name: 'Whole Foods' },
+];
+export function getStoreInfo(url) {
+    try {
+        const hostname = new URL(url).hostname.replace('www.', '');
+        for (const s of SHOPPING_DOMAINS) {
+            if (hostname === s.pattern || hostname.endsWith('.' + s.pattern))
+                return { store: s.name, domain: s.pattern };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function parsePrice(text) {
+    if (!text)
+        return undefined;
+    const rangeMatch = text.match(/\$\s*([\d,]+(?:\.\d{2})?)\s*[-–—to]+\s*\$\s*([\d,]+(?:\.\d{2})?)/i);
+    if (rangeMatch) {
+        const lo = rangeMatch[1].replace(/,/g, '');
+        return `from $${parseFloat(lo).toLocaleString('en-US', { minimumFractionDigits: 0 })}`;
+    }
+    const fromMatch = text.match(/from\s+\$\s*([\d,]+(?:\.\d{2})?)/i);
+    if (fromMatch) {
+        const val = parseFloat(fromMatch[1].replace(/,/g, ''));
+        return `from $${val.toLocaleString('en-US', { minimumFractionDigits: 0 })}`;
+    }
+    const plainMatch = text.match(/\$\s*([\d,]+(?:\.\d{2})?)/);
+    if (plainMatch) {
+        const val = parseFloat(plainMatch[1].replace(/,/g, ''));
+        if (isNaN(val))
+            return undefined;
+        if (val > 50000)
+            return undefined;
+        return `$${val.toLocaleString('en-US', { minimumFractionDigits: val % 1 !== 0 ? 2 : 0 })}`;
+    }
+    return undefined;
+}
+export function extractPriceValue(priceStr) {
+    if (!priceStr)
+        return undefined;
+    const match = priceStr.match(/\$\s*([\d,]+(?:\.\d+)?)/);
+    return match ? parseFloat(match[1].replace(/,/g, '')) : undefined;
+}
+export function cleanProductTitle(title) {
+    return title
+        .replace(/^amazon\.com\s*[:\-–—]\s*/i, '')
+        .replace(/^walmart\s*[:\-–—]\s*/i, '')
+        .replace(/^target\s*[:\-–—]\s*/i, '')
+        .replace(/^best\s*buy\s*[:\-–—]\s*/i, '')
+        .replace(/^ebay\s*[:\-–—]\s*/i, '')
+        .trim();
+}

package/dist/server/routes/stats.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Stats endpoint - provides dashboard statistics
+ */
+import { Router } from 'express';
+import { AuthStore } from '../auth-store.js';
+export declare function createStatsRouter(authStore: AuthStore): Router;

package/dist/server/routes/stats.js

@@ -0,0 +1,71 @@
+/**
+ * Stats endpoint - provides dashboard statistics
+ */
+import { Router } from 'express';
+import { PostgresAuthStore } from '../pg-auth-store.js';
+export function createStatsRouter(authStore) {
+    const router = Router();
+    router.get('/v1/stats', async (req, res) => {
+        try {
+            // Require authentication (API key or JWT session token)
+            const userId = req.auth?.keyInfo?.accountId || req.user?.userId;
+            if (!userId) {
+                res.status(401).json({ success: false, error: { type: 'unauthorized', message: 'Authentication required.', docs: 'https://webpeel.dev/docs/authentication' }, requestId: req.requestId });
+                return;
+            }
+            // Only works with PostgreSQL backend
+            if (!(authStore instanceof PostgresAuthStore)) {
+                res.status(501).json({
+                    success: false,
+                    error: {
+                        type: 'not_implemented',
+                        message: 'Stats endpoint requires PostgreSQL backend',
+                        docs: 'https://webpeel.dev/docs/errors#not_implemented',
+                    },
+                    requestId: req.requestId,
+                });
+                return;
+            }
+            // Access pool via any cast (pool is private but we need direct DB access)
+            const pgStore = authStore;
+            // Get stats from usage_logs table
+            const statsQuery = `
+        SELECT 
+          COUNT(*) as total_requests,
+          AVG(CASE WHEN status_code >= 200 AND status_code < 300 THEN 1.0 ELSE 0.0 END) * 100 as success_rate,
+          AVG(processing_time_ms) as avg_response_time
+        FROM usage_logs
+        WHERE user_id = $1
+      `;
+            const result = await pgStore.pool.query(statsQuery, [userId]);
+            if (result.rows.length === 0) {
+                // No data yet - return defaults
+                res.json({
+                    totalRequests: 0,
+                    successRate: 100,
+                    avgResponseTime: 0,
+                });
+                return;
+            }
+            const row = result.rows[0];
+            res.json({
+                totalRequests: parseInt(row.total_requests) || 0,
+                successRate: parseFloat(row.success_rate) || 100,
+                avgResponseTime: Math.round(parseFloat(row.avg_response_time)) || 0,
+            });
+        }
+        catch (error) {
+            console.error('Stats error:', error);
+            res.status(500).json({
+                success: false,
+                error: {
+                    type: 'internal_error',
+                    message: 'Failed to retrieve stats',
+                    docs: 'https://webpeel.dev/docs/errors#internal_error',
+                },
+                requestId: req.requestId,
+            });
+        }
+    });
+    return router;
+}

package/dist/server/routes/stripe.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stripe webhook handler for subscription management
+ */
+import { Router } from 'express';
+import pg from 'pg';
+/**
+ * Create Stripe Billing Portal router
+ * POST /v1/billing/portal — create a Stripe Customer Portal session
+ * Requires global auth middleware to already have run (req.user or req.auth set).
+ */
+export declare function createBillingPortalRouter(pool: pg.Pool | null): Router;
+/**
+ * Create Stripe webhook router
+ */
+export declare function createStripeRouter(): Router;

package/dist/server/routes/stripe.js

@@ -0,0 +1,296 @@
+/**
+ * Stripe webhook handler for subscription management
+ */
+import { Router } from 'express';
+import Stripe from 'stripe';
+import pg from 'pg';
+import { createLogger } from '../logger.js';
+const log = createLogger('stripe');
+const { Pool } = pg;
+/**
+ * Tier configuration (weekly usage model)
+ */
+const TIER_LIMITS = {
+    free: { weekly_limit: 500, burst_limit: 50, rate_limit: 10 },
+    pro: { weekly_limit: 1250, burst_limit: 100, rate_limit: 60 },
+    max: { weekly_limit: 6250, burst_limit: 500, rate_limit: 200 },
+    admin: { weekly_limit: 100000, burst_limit: 10000, rate_limit: 1000 },
+    enterprise: { weekly_limit: 50000, burst_limit: 2000, rate_limit: 500 },
+};
+/**
+ * Create Stripe Billing Portal router
+ * POST /v1/billing/portal — create a Stripe Customer Portal session
+ * Requires global auth middleware to already have run (req.user or req.auth set).
+ */
+export function createBillingPortalRouter(pool) {
+    const router = Router();
+    const stripeSecretKey = process.env.STRIPE_SECRET_KEY;
+    if (!stripeSecretKey) {
+        log.warn('STRIPE_SECRET_KEY not configured - billing portal disabled');
+        return router;
+    }
+    const stripe = new Stripe(stripeSecretKey);
+    router.post('/v1/billing/portal', async (req, res) => {
+        try {
+            const userId = req.user?.userId || req.auth?.keyInfo?.accountId;
+            if (!userId) {
+                res.status(401).json({ success: false, error: { type: 'unauthorized', message: 'Authentication required.', docs: 'https://webpeel.dev/docs/authentication' }, requestId: req.requestId });
+                return;
+            }
+            if (!pool) {
+                res.status(503).json({
+                    success: false,
+                    error: {
+                        type: 'db_unavailable',
+                        message: 'Database not configured',
+                        docs: 'https://webpeel.dev/docs/errors#db_unavailable',
+                    },
+                    requestId: req.requestId,
+                });
+                return;
+            }
+            // Get user's stripe_customer_id from DB
+            const result = await pool.query('SELECT stripe_customer_id FROM users WHERE id = $1', [userId]);
+            const stripeCustomerId = result.rows[0]?.stripe_customer_id;
+            if (!stripeCustomerId) {
+                res.status(400).json({ success: false, error: { type: 'no_subscription', message: 'No active subscription found. Upgrade to Pro or Max to manage billing.', hint: 'Upgrade at https://webpeel.dev/pricing', docs: 'https://webpeel.dev/docs/errors#no_subscription' }, requestId: req.requestId });
+                return;
+            }
+            // Create portal session
+            const session = await stripe.billingPortal.sessions.create({
+                customer: stripeCustomerId,
+                return_url: 'https://app.webpeel.dev/billing',
+            });
+            res.json({ url: session.url });
+        }
+        catch (err) {
+            log.error('Failed to create portal session:', err);
+            res.status(500).json({
+                success: false,
+                error: {
+                    type: 'portal_failed',
+                    message: 'Failed to create billing portal session',
+                    docs: 'https://webpeel.dev/docs/errors#portal_failed',
+                },
+                requestId: req.requestId,
+            });
+        }
+    });
+    return router;
+}
+/**
+ * Create Stripe webhook router
+ */
+export function createStripeRouter() {
+    const router = Router();
+    const stripeSecretKey = process.env.STRIPE_SECRET_KEY;
+    const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+    const dbUrl = process.env.DATABASE_URL;
+    if (!stripeSecretKey) {
+        log.warn('STRIPE_SECRET_KEY not configured - Stripe webhooks disabled');
+        return router;
+    }
+    if (!webhookSecret) {
+        log.warn('STRIPE_WEBHOOK_SECRET not configured - Stripe webhooks disabled');
+        return router;
+    }
+    if (!dbUrl) {
+        throw new Error('DATABASE_URL environment variable is required');
+    }
+    const stripe = new Stripe(stripeSecretKey);
+    const pool = new Pool({
+        connectionString: dbUrl,
+        // TLS: enabled when DATABASE_URL contains sslmode=require.
+        // Secure by default (rejectUnauthorized: true); set PG_REJECT_UNAUTHORIZED=false
+        // only for managed DBs (Render/Neon/Supabase) that use self-signed certs.
+        ssl: process.env.DATABASE_URL?.includes('sslmode=require')
+            ? { rejectUnauthorized: process.env.PG_REJECT_UNAUTHORIZED !== 'false' }
+            : undefined,
+    });
+    /**
+     * POST /v1/webhooks/stripe
+     * Handle Stripe webhook events
+     * SECURITY: Verifies webhook signature
+     */
+    router.post('/', async (req, res) => {
+        try {
+            const sig = req.headers['stripe-signature'];
+            if (!sig || typeof sig !== 'string') {
+                res.status(400).json({ success: false, error: { type: 'missing_signature', message: 'Stripe signature header missing', hint: 'Ensure the request includes the stripe-signature header', docs: 'https://webpeel.dev/docs/errors#missing_signature' }, requestId: req.requestId });
+                return;
+            }
+            // SECURITY: Verify webhook signature
+            let event;
+            try {
+                event = stripe.webhooks.constructEvent(req.body, sig, webhookSecret);
+            }
+            catch (err) {
+                log.error('Webhook signature verification failed', { message: err.message });
+                res.status(400).json({ success: false, error: { type: 'invalid_signature', message: 'Webhook signature verification failed', hint: 'Verify your STRIPE_WEBHOOK_SECRET matches the Stripe dashboard', docs: 'https://webpeel.dev/docs/errors#invalid_signature' }, requestId: req.requestId });
+                return;
+            }
+            // Handle different event types
+            switch (event.type) {
+                case 'checkout.session.completed': {
+                    const session = event.data.object;
+                    await handleCheckoutCompleted(pool, session);
+                    break;
+                }
+                case 'customer.subscription.updated': {
+                    const subscription = event.data.object;
+                    await handleSubscriptionUpdated(pool, subscription);
+                    break;
+                }
+                case 'customer.subscription.deleted': {
+                    const subscription = event.data.object;
+                    await handleSubscriptionDeleted(pool, subscription);
+                    break;
+                }
+                case 'invoice.payment_failed': {
+                    const invoice = event.data.object;
+                    await handlePaymentFailed(pool, invoice);
+                    break;
+                }
+                default:
+                    log.warn(`Unhandled Stripe event type: ${event.type}`);
+            }
+            res.json({ received: true });
+        }
+        catch (error) {
+            log.error('Webhook error', { error: error instanceof Error ? error.message : String(error) });
+            res.status(500).json({
+                success: false,
+                error: {
+                    type: 'webhook_failed',
+                    message: 'Failed to process webhook',
+                    docs: 'https://webpeel.dev/docs/errors#webhook_failed',
+                },
+                requestId: req.requestId,
+            });
+        }
+    });
+    return router;
+}
+/**
+ * Handle checkout.session.completed
+ * Upgrade user tier and set limits
+ */
+async function handleCheckoutCompleted(pool, session) {
+    try {
+        const customerId = session.customer;
+        const subscriptionId = session.subscription;
+        // Get subscription to determine tier
+        const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
+        const subscription = await stripe.subscriptions.retrieve(subscriptionId);
+        // Determine tier from price ID (you'll need to configure these)
+        const priceId = subscription.items.data[0]?.price.id;
+        const tier = getTierFromPriceId(priceId);
+        const limits = TIER_LIMITS[tier];
+        // Update user
+        await pool.query(`UPDATE users 
+      SET 
+        stripe_customer_id = $1,
+        stripe_subscription_id = $2,
+        tier = $3,
+        weekly_limit = $4,
+        burst_limit = $5,
+        rate_limit = $6,
+        updated_at = now()
+      WHERE stripe_customer_id = $1 OR email = $7`, [
+            customerId,
+            subscriptionId,
+            tier,
+            limits.weekly_limit,
+            limits.burst_limit,
+            limits.rate_limit,
+            session.customer_email,
+        ]);
+        log.info(`Checkout completed for customer ${customerId}: upgraded to ${tier}`);
+    }
+    catch (error) {
+        log.error('Failed to handle checkout completion', { error: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}
+/**
+ * Handle customer.subscription.updated
+ * Update user tier based on subscription changes
+ */
+async function handleSubscriptionUpdated(pool, subscription) {
+    try {
+        const customerId = subscription.customer;
+        const priceId = subscription.items.data[0]?.price.id;
+        const tier = getTierFromPriceId(priceId);
+        const limits = TIER_LIMITS[tier];
+        await pool.query(`UPDATE users 
+      SET 
+        tier = $1,
+        weekly_limit = $2,
+        burst_limit = $3,
+        rate_limit = $4,
+        stripe_subscription_id = $5,
+        updated_at = now()
+      WHERE stripe_customer_id = $6`, [tier, limits.weekly_limit, limits.burst_limit, limits.rate_limit, subscription.id, customerId]);
+        log.info(`Subscription updated for customer ${customerId}: tier=${tier}`);
+    }
+    catch (error) {
+        log.error('Failed to handle subscription update', { error: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}
+/**
+ * Handle customer.subscription.deleted
+ * Downgrade user to free tier
+ */
+async function handleSubscriptionDeleted(pool, subscription) {
+    try {
+        const customerId = subscription.customer;
+        const limits = TIER_LIMITS.free;
+        await pool.query(`UPDATE users 
+      SET 
+        tier = 'free',
+        weekly_limit = $1,
+        burst_limit = $2,
+        rate_limit = $3,
+        stripe_subscription_id = NULL,
+        updated_at = now()
+      WHERE stripe_customer_id = $4`, [limits.weekly_limit, limits.burst_limit, limits.rate_limit, customerId]);
+        log.info(`Subscription deleted for customer ${customerId}: downgraded to free`);
+    }
+    catch (error) {
+        log.error('Failed to handle subscription deletion', { error: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}
+/**
+ * Handle invoice.payment_failed
+ * Log payment failure (could add email notification here)
+ */
+async function handlePaymentFailed(pool, invoice) {
+    try {
+        const customerId = invoice.customer;
+        // Get user email for logging
+        const result = await pool.query('SELECT email FROM users WHERE stripe_customer_id = $1', [customerId]);
+        if (result.rows.length > 0) {
+            log.warn(`Payment failed for customer ${customerId}`, { email: result.rows[0].email });
+            // Note: Email notification not implemented. Log only for now.
+        }
+    }
+    catch (error) {
+        log.error('Failed to handle payment failure', { error: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}
+/**
+ * Map Stripe price ID to tier
+ * Maps Stripe price IDs to tiers (configured via STRIPE_PRICE_PRO and STRIPE_PRICE_MAX env vars)
+ */
+function getTierFromPriceId(priceId) {
+    // Map price IDs to tiers
+    const priceMap = {
+        // Add your Stripe price IDs here
+        [process.env.STRIPE_PRICE_PRO || '']: 'pro',
+        [process.env.STRIPE_PRICE_MAX || '']: 'max',
+    };
+    return priceMap[priceId] || 'free';
+}

package/dist/server/routes/transcript-export.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Transcript export endpoint
+ *
+ * GET /v1/transcript/export?url=<youtube_url>&format=srt|txt|md|json
+ *
+ * Downloads a YouTube transcript in the requested format with appropriate
+ * Content-Type and Content-Disposition headers.
+ */
+import { Router } from 'express';
+export declare function createTranscriptExportRouter(): Router;