lokicms-plugin-stripe 1.0.0

package/src/index.ts

@@ -0,0 +1,1092 @@
+/**
+ * Stripe Plugin for LokiCMS
+ * Provides payment processing and subscription management via Stripe
+ */
+
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { StripeService } from './stripe-service';
+import type {
+  PluginDefinition,
+  PluginAPI,
+  StripeConfig,
+  ContentTypeRegistration,
+} from './types';
+
+// ============================================================================
+// Content Types
+// ============================================================================
+
+// Content type slugs get prefixed with plugin name by LokiCMS
+const CT_PRODUCT = 'stripe-stripe-product';
+const CT_PRICE = 'stripe-stripe-price';
+const CT_SUBSCRIPTION = 'stripe-stripe-subscription';
+const CT_INVOICE = 'stripe-stripe-invoice';
+const CT_CUSTOMER = 'stripe-stripe-customer';
+
+// Convert Stripe IDs to valid slugs (prod_xxx -> prod-xxx)
+function toSlug(stripeId: string): string {
+  return stripeId.toLowerCase().replace(/_/g, '-');
+}
+
+const CONTENT_TYPES: ContentTypeRegistration[] = [
+  {
+    name: 'Stripe Product',
+    slug: CT_PRODUCT,
+    description: 'Products synced from Stripe',
+    fields: [
+      { name: 'stripeId', label: 'Stripe ID', type: 'text', required: true },
+      { name: 'name', label: 'Name', type: 'text', required: true },
+      { name: 'description', label: 'Description', type: 'textarea' },
+      { name: 'active', label: 'Active', type: 'boolean' },
+      { name: 'metadata', label: 'Metadata', type: 'json' },
+    ],
+    titleField: 'name',
+  },
+  {
+    name: 'Stripe Price',
+    slug: CT_PRICE,
+    description: 'Prices synced from Stripe',
+    fields: [
+      { name: 'stripeId', label: 'Stripe ID', type: 'text', required: true },
+      { name: 'productId', label: 'Product ID', type: 'text', required: true },
+      { name: 'active', label: 'Active', type: 'boolean' },
+      { name: 'currency', label: 'Currency', type: 'text', required: true },
+      { name: 'unitAmount', label: 'Unit Amount (cents)', type: 'number', required: true },
+      { name: 'type', label: 'Type', type: 'select', validation: { options: ['one_time', 'recurring'] } },
+      { name: 'interval', label: 'Interval', type: 'select', validation: { options: ['day', 'week', 'month', 'year'] } },
+      { name: 'intervalCount', label: 'Interval Count', type: 'number' },
+      { name: 'trialPeriodDays', label: 'Trial Period (days)', type: 'number' },
+    ],
+    titleField: 'stripeId',
+  },
+  {
+    name: 'Stripe Subscription',
+    slug: CT_SUBSCRIPTION,
+    description: 'Customer subscriptions from Stripe',
+    fields: [
+      { name: 'stripeId', label: 'Stripe ID', type: 'text', required: true },
+      { name: 'customerId', label: 'Customer ID', type: 'text', required: true },
+      { name: 'customerEmail', label: 'Customer Email', type: 'email' },
+      { name: 'priceId', label: 'Price ID', type: 'text', required: true },
+      { name: 'status', label: 'Status', type: 'select', validation: {
+        options: ['active', 'canceled', 'incomplete', 'incomplete_expired', 'past_due', 'trialing', 'unpaid', 'paused']
+      }},
+      { name: 'currentPeriodStart', label: 'Current Period Start', type: 'datetime' },
+      { name: 'currentPeriodEnd', label: 'Current Period End', type: 'datetime' },
+      { name: 'cancelAtPeriodEnd', label: 'Cancel at Period End', type: 'boolean' },
+      { name: 'canceledAt', label: 'Canceled At', type: 'datetime' },
+      { name: 'trialStart', label: 'Trial Start', type: 'datetime' },
+      { name: 'trialEnd', label: 'Trial End', type: 'datetime' },
+      { name: 'userId', label: 'LokiCMS User ID', type: 'text' },
+    ],
+    titleField: 'stripeId',
+  },
+  {
+    name: 'Stripe Invoice',
+    slug: CT_INVOICE,
+    description: 'Invoices from Stripe',
+    fields: [
+      { name: 'stripeId', label: 'Stripe ID', type: 'text', required: true },
+      { name: 'customerId', label: 'Customer ID', type: 'text', required: true },
+      { name: 'subscriptionId', label: 'Subscription ID', type: 'text' },
+      { name: 'status', label: 'Status', type: 'select', validation: {
+        options: ['draft', 'open', 'paid', 'void', 'uncollectible']
+      }},
+      { name: 'amountDue', label: 'Amount Due (cents)', type: 'number' },
+      { name: 'amountPaid', label: 'Amount Paid (cents)', type: 'number' },
+      { name: 'currency', label: 'Currency', type: 'text' },
+      { name: 'hostedInvoiceUrl', label: 'Invoice URL', type: 'url' },
+      { name: 'invoicePdf', label: 'PDF URL', type: 'url' },
+      { name: 'paidAt', label: 'Paid At', type: 'datetime' },
+    ],
+    titleField: 'stripeId',
+  },
+  {
+    name: 'Stripe Customer',
+    slug: CT_CUSTOMER,
+    description: 'Customers synced from Stripe',
+    fields: [
+      { name: 'stripeId', label: 'Stripe ID', type: 'text', required: true },
+      { name: 'email', label: 'Email', type: 'email', required: true },
+      { name: 'name', label: 'Name', type: 'text' },
+      { name: 'userId', label: 'LokiCMS User ID', type: 'text' },
+      { name: 'metadata', label: 'Metadata', type: 'json' },
+    ],
+    titleField: 'email',
+  },
+];
+
+// ============================================================================
+// MCP Tool Schemas
+// ============================================================================
+
+const CreateCheckoutSchema = z.object({
+  priceId: z.string().describe('The Stripe Price ID'),
+  customerEmail: z.string().email().optional().describe('Customer email'),
+  customerId: z.string().optional().describe('Existing Stripe Customer ID'),
+  userId: z.string().optional().describe('LokiCMS User ID to associate'),
+  mode: z.enum(['payment', 'subscription']).default('subscription'),
+  quantity: z.number().positive().optional().default(1),
+  trialDays: z.number().positive().optional().describe('Trial period in days'),
+});
+
+const CreatePortalSchema = z.object({
+  customerId: z.string().describe('Stripe Customer ID'),
+  returnUrl: z.string().url().optional().describe('Return URL after portal'),
+});
+
+const GetSubscriptionSchema = z.object({
+  subscriptionId: z.string().describe('Stripe Subscription ID'),
+});
+
+const CancelSubscriptionSchema = z.object({
+  subscriptionId: z.string().describe('Stripe Subscription ID'),
+  atPeriodEnd: z.boolean().default(true).describe('Cancel at end of billing period'),
+});
+
+const ListProductsSchema = z.object({
+  active: z.boolean().optional().describe('Filter by active status'),
+  limit: z.number().positive().max(100).optional().default(20),
+});
+
+const ListPricesSchema = z.object({
+  productId: z.string().optional().describe('Filter by product'),
+  active: z.boolean().optional().describe('Filter by active status'),
+  type: z.enum(['one_time', 'recurring']).optional().describe('Filter by price type'),
+  limit: z.number().positive().max(100).optional().default(20),
+});
+
+const ListSubscriptionsSchema = z.object({
+  customerId: z.string().optional().describe('Filter by customer'),
+  status: z.string().optional().describe('Filter by status'),
+  limit: z.number().positive().max(100).optional().default(20),
+});
+
+const ListInvoicesSchema = z.object({
+  customerId: z.string().optional().describe('Filter by customer'),
+  subscriptionId: z.string().optional().describe('Filter by subscription'),
+  status: z.string().optional().describe('Filter by status'),
+  limit: z.number().positive().max(100).optional().default(20),
+});
+
+const SyncProductsSchema = z.object({
+  active: z.boolean().optional().default(true).describe('Only sync active products'),
+});
+
+// ============================================================================
+// Plugin Definition
+// ============================================================================
+
+let stripeService: StripeService | null = null;
+let pluginApi: PluginAPI | null = null;
+
+const stripePlugin: PluginDefinition = {
+  name: 'stripe',
+  displayName: 'Stripe Payments',
+  version: '1.0.0',
+  description: 'Accept payments and manage subscriptions with Stripe',
+
+  lifecycle: {
+    onLoad: () => {
+      console.log('[Stripe] Plugin loaded');
+    },
+    onEnable: () => {
+      console.log('[Stripe] Plugin enabled');
+    },
+    onDisable: () => {
+      console.log('[Stripe] Plugin disabled');
+      stripeService = null;
+    },
+  },
+
+  setup: async (api: PluginAPI) => {
+    pluginApi = api;
+    const config = api.config.getAll() as unknown as StripeConfig;
+
+    // Validate configuration
+    if (!config.secretKey) {
+      api.logger.error('Stripe secret key not configured');
+      return;
+    }
+
+    // Initialize Stripe service
+    stripeService = new StripeService({
+      secretKey: config.secretKey,
+      webhookSecret: config.webhookSecret || '',
+      successUrl: config.successUrl || 'https://localhost:3000/checkout/success',
+      cancelUrl: config.cancelUrl || 'https://localhost:3000/checkout/cancel',
+      portalReturnUrl: config.portalReturnUrl || 'https://localhost:3000/account',
+      currency: config.currency || 'usd',
+    });
+
+    api.logger.info('Stripe service initialized');
+
+    // Register content types
+    for (const contentType of CONTENT_TYPES) {
+      try {
+        await api.contentTypes.register(contentType);
+        api.logger.debug(`Registered content type: ${contentType.slug}`);
+      } catch (error) {
+        api.logger.debug(`Content type ${contentType.slug} may already exist`);
+      }
+    }
+
+    // Register routes
+    const routes = createRoutes(api);
+    api.routes.register(routes);
+    api.logger.info(`Routes registered at ${api.routes.getBasePath()}`);
+
+    // Register MCP tools
+    registerMCPTools(api);
+    api.logger.info('MCP tools registered');
+
+    // Register hooks for user-customer sync
+    api.hooks.on('user:afterCreate', async (payload) => {
+      const user = payload as { id: string; email: string; name?: string };
+      if (stripeService && config.secretKey) {
+        try {
+          const customer = await stripeService.createCustomer({
+            email: user.email,
+            name: user.name,
+            metadata: { lokicms_user_id: user.id },
+          });
+          api.logger.info(`Created Stripe customer ${customer.id} for user ${user.id}`);
+        } catch (error) {
+          api.logger.error(`Failed to create Stripe customer for user ${user.id}`);
+        }
+      }
+    });
+
+    api.logger.info('Stripe plugin setup complete');
+  },
+};
+
+// ============================================================================
+// Routes
+// ============================================================================
+
+function createRoutes(api: PluginAPI): Hono {
+  const app = new Hono();
+
+  // Health check
+  app.get('/health', (c) => {
+    return c.json({
+      status: 'ok',
+      service: 'stripe',
+      configured: stripeService !== null,
+    });
+  });
+
+  // Create checkout session
+  app.post('/checkout', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const body = await c.req.json();
+      const parsed = CreateCheckoutSchema.parse(body);
+
+      const session = await stripeService.createCheckoutSession({
+        priceId: parsed.priceId,
+        customerEmail: parsed.customerEmail,
+        customerId: parsed.customerId,
+        userId: parsed.userId,
+        mode: parsed.mode,
+        quantity: parsed.quantity,
+        trialPeriodDays: parsed.trialDays,
+      });
+
+      return c.json(session);
+    } catch (error) {
+      api.logger.error('Checkout error:', error);
+      return c.json({ error: 'Failed to create checkout session' }, 400);
+    }
+  });
+
+  // Create customer portal session
+  app.post('/portal', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const body = await c.req.json();
+      const parsed = CreatePortalSchema.parse(body);
+
+      const session = await stripeService.createPortalSession({
+        customerId: parsed.customerId,
+        returnUrl: parsed.returnUrl,
+      });
+
+      return c.json(session);
+    } catch (error) {
+      api.logger.error('Portal error:', error);
+      return c.json({ error: 'Failed to create portal session' }, 400);
+    }
+  });
+
+  // List products
+  app.get('/products', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const active = c.req.query('active');
+      const limit = parseInt(c.req.query('limit') || '20');
+
+      const products = await stripeService.listProducts({
+        active: active !== undefined ? active === 'true' : undefined,
+        limit,
+      });
+
+      return c.json({ products });
+    } catch (error) {
+      api.logger.error('List products error:', error);
+      return c.json({ error: 'Failed to list products' }, 500);
+    }
+  });
+
+  // List prices
+  app.get('/prices', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const productId = c.req.query('productId');
+      const active = c.req.query('active');
+      const type = c.req.query('type') as 'one_time' | 'recurring' | undefined;
+      const limit = parseInt(c.req.query('limit') || '20');
+
+      const prices = await stripeService.listPrices({
+        productId,
+        active: active !== undefined ? active === 'true' : undefined,
+        type,
+        limit,
+      });
+
+      return c.json({ prices });
+    } catch (error) {
+      api.logger.error('List prices error:', error);
+      return c.json({ error: 'Failed to list prices' }, 500);
+    }
+  });
+
+  // Get subscription
+  app.get('/subscriptions/:id', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const subscription = await stripeService.getSubscription(c.req.param('id'));
+      if (!subscription) {
+        return c.json({ error: 'Subscription not found' }, 404);
+      }
+      return c.json(subscription);
+    } catch (error) {
+      api.logger.error('Get subscription error:', error);
+      return c.json({ error: 'Failed to get subscription' }, 500);
+    }
+  });
+
+  // List subscriptions
+  app.get('/subscriptions', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const customerId = c.req.query('customerId');
+      const status = c.req.query('status');
+      const limit = parseInt(c.req.query('limit') || '20');
+
+      const subscriptions = await stripeService.listSubscriptions({
+        customerId,
+        status,
+        limit,
+      });
+
+      return c.json({ subscriptions });
+    } catch (error) {
+      api.logger.error('List subscriptions error:', error);
+      return c.json({ error: 'Failed to list subscriptions' }, 500);
+    }
+  });
+
+  // Cancel subscription
+  app.post('/subscriptions/:id/cancel', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const atPeriodEnd = body.atPeriodEnd !== false;
+
+      const subscription = await stripeService.cancelSubscription(
+        c.req.param('id'),
+        { atPeriodEnd }
+      );
+
+      return c.json(subscription);
+    } catch (error) {
+      api.logger.error('Cancel subscription error:', error);
+      return c.json({ error: 'Failed to cancel subscription' }, 500);
+    }
+  });
+
+  // Resume subscription
+  app.post('/subscriptions/:id/resume', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const subscription = await stripeService.resumeSubscription(c.req.param('id'));
+      return c.json(subscription);
+    } catch (error) {
+      api.logger.error('Resume subscription error:', error);
+      return c.json({ error: 'Failed to resume subscription' }, 500);
+    }
+  });
+
+  // List invoices
+  app.get('/invoices', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const customerId = c.req.query('customerId');
+      const subscriptionId = c.req.query('subscriptionId');
+      const status = c.req.query('status');
+      const limit = parseInt(c.req.query('limit') || '20');
+
+      const invoices = await stripeService.listInvoices({
+        customerId,
+        subscriptionId,
+        status,
+        limit,
+      });
+
+      return c.json({ invoices });
+    } catch (error) {
+      api.logger.error('List invoices error:', error);
+      return c.json({ error: 'Failed to list invoices' }, 500);
+    }
+  });
+
+  // Webhook handler
+  app.post('/webhook', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const signature = c.req.header('stripe-signature');
+      if (!signature) {
+        return c.json({ error: 'Missing stripe-signature header' }, 400);
+      }
+
+      const rawBody = await c.req.text();
+      const event = stripeService.verifyWebhookSignature(rawBody, signature);
+
+      // Process webhook event
+      await handleWebhookEvent(event, api);
+
+      return c.json({ received: true });
+    } catch (error) {
+      api.logger.error('Webhook error:', error);
+      return c.json({ error: 'Webhook verification failed' }, 400);
+    }
+  });
+
+  // Sync products from Stripe to LokiCMS
+  app.post('/sync/products', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const products = await stripeService.listProducts({ active: true });
+      let synced = 0;
+
+      for (const product of products) {
+        try {
+          // Check if exists
+          const slug = toSlug(product.id);
+          const existing = await api.services.entries.findBySlug(
+            CT_PRODUCT,
+            slug
+          );
+
+          const entryData = {
+            contentTypeSlug: CT_PRODUCT,
+            title: product.name,
+            slug,
+            content: {
+              stripeId: product.id,
+              name: product.name,
+              description: product.description,
+              active: product.active,
+              metadata: product.metadata,
+            },
+            status: 'published',
+          };
+
+          if (existing) {
+            await api.services.entries.update((existing as { id: string }).id, entryData);
+          } else {
+            await api.services.entries.create(entryData, 'system', 'Stripe Sync');
+          }
+          synced++;
+        } catch (err) {
+          api.logger.error(`Failed to sync product ${product.id}:`, err);
+        }
+      }
+
+      return c.json({ synced, total: products.length });
+    } catch (error) {
+      api.logger.error('Sync products error:', error);
+      return c.json({ error: 'Failed to sync products' }, 500);
+    }
+  });
+
+  // Sync prices from Stripe to LokiCMS
+  app.post('/sync/prices', async (c) => {
+    if (!stripeService) {
+      return c.json({ error: 'Stripe not configured' }, 500);
+    }
+
+    try {
+      const prices = await stripeService.listPrices({ active: true });
+      let synced = 0;
+
+      for (const price of prices) {
+        try {
+          const slug = toSlug(price.id);
+          const existing = await api.services.entries.findBySlug(
+            CT_PRICE,
+            slug
+          );
+
+          const entryData = {
+            contentTypeSlug: CT_PRICE,
+            title: `${price.id} - ${price.unitAmount / 100} ${price.currency.toUpperCase()}`,
+            slug,
+            content: {
+              stripeId: price.id,
+              productId: price.productId,
+              active: price.active,
+              currency: price.currency,
+              unitAmount: price.unitAmount,
+              type: price.type,
+              interval: price.interval,
+              intervalCount: price.intervalCount,
+              trialPeriodDays: price.trialPeriodDays,
+            },
+            status: 'published',
+          };
+
+          if (existing) {
+            await api.services.entries.update((existing as { id: string }).id, entryData);
+          } else {
+            await api.services.entries.create(entryData, 'system', 'Stripe Sync');
+          }
+          synced++;
+        } catch (err) {
+          api.logger.error(`Failed to sync price ${price.id}:`, err);
+        }
+      }
+
+      return c.json({ synced, total: prices.length });
+    } catch (error) {
+      api.logger.error('Sync prices error:', error);
+      return c.json({ error: 'Failed to sync prices' }, 500);
+    }
+  });
+
+  return app;
+}
+
+// ============================================================================
+// Webhook Event Handler
+// ============================================================================
+
+async function handleWebhookEvent(
+  event: { id: string; type: string; data: { object: unknown } },
+  api: PluginAPI
+): Promise<void> {
+  api.logger.info(`Processing webhook: ${event.type}`);
+
+  switch (event.type) {
+    case 'customer.subscription.created':
+    case 'customer.subscription.updated':
+      await syncSubscription(event.data.object as SubscriptionObject, api);
+      break;
+
+    case 'customer.subscription.deleted':
+      await handleSubscriptionDeleted(event.data.object as SubscriptionObject, api);
+      break;
+
+    case 'invoice.paid':
+    case 'invoice.payment_failed':
+    case 'invoice.created':
+      await syncInvoice(event.data.object as InvoiceObject, api);
+      break;
+
+    case 'checkout.session.completed':
+      await handleCheckoutCompleted(event.data.object as CheckoutObject, api);
+      break;
+
+    case 'product.created':
+    case 'product.updated':
+      await syncProduct(event.data.object as ProductObject, api);
+      break;
+
+    case 'price.created':
+    case 'price.updated':
+      await syncPrice(event.data.object as PriceObject, api);
+      break;
+
+    default:
+      api.logger.debug(`Unhandled webhook event: ${event.type}`);
+  }
+}
+
+// Type helpers for webhook objects
+interface SubscriptionObject {
+  id: string;
+  customer: string;
+  items: { data: Array<{ price: { id: string } }> };
+  status: string;
+  current_period_start: number;
+  current_period_end: number;
+  cancel_at_period_end: boolean;
+  canceled_at?: number;
+  trial_start?: number;
+  trial_end?: number;
+  metadata?: Record<string, string>;
+}
+
+interface InvoiceObject {
+  id: string;
+  customer: string;
+  subscription?: string;
+  status: string;
+  amount_due: number;
+  amount_paid: number;
+  currency: string;
+  hosted_invoice_url?: string;
+  invoice_pdf?: string;
+  status_transitions?: { paid_at?: number };
+}
+
+interface CheckoutObject {
+  id: string;
+  customer: string;
+  subscription?: string;
+  client_reference_id?: string;
+  metadata?: Record<string, string>;
+}
+
+interface ProductObject {
+  id: string;
+  name: string;
+  description?: string;
+  active: boolean;
+  metadata?: Record<string, string>;
+}
+
+interface PriceObject {
+  id: string;
+  product: string;
+  active: boolean;
+  currency: string;
+  unit_amount: number;
+  type: string;
+  recurring?: {
+    interval: string;
+    interval_count: number;
+    trial_period_days?: number;
+  };
+}
+
+async function syncSubscription(sub: SubscriptionObject, api: PluginAPI): Promise<void> {
+  try {
+    const slug = toSlug(sub.id);
+    const existing = await api.services.entries.findBySlug(CT_SUBSCRIPTION, slug);
+
+    // Get customer email if possible
+    let customerEmail = '';
+    if (stripeService) {
+      const customer = await stripeService.getCustomer(sub.customer);
+      customerEmail = customer?.email || '';
+    }
+
+    const entryData = {
+      contentTypeSlug: CT_SUBSCRIPTION,
+      title: sub.id,
+      slug,
+      content: {
+        stripeId: sub.id,
+        customerId: sub.customer,
+        customerEmail,
+        priceId: sub.items.data[0]?.price.id,
+        status: sub.status,
+        currentPeriodStart: sub.current_period_start * 1000,
+        currentPeriodEnd: sub.current_period_end * 1000,
+        cancelAtPeriodEnd: sub.cancel_at_period_end,
+        canceledAt: sub.canceled_at ? sub.canceled_at * 1000 : null,
+        trialStart: sub.trial_start ? sub.trial_start * 1000 : null,
+        trialEnd: sub.trial_end ? sub.trial_end * 1000 : null,
+        userId: sub.metadata?.lokicms_user_id,
+      },
+      status: 'published',
+    };
+
+    if (existing) {
+      await api.services.entries.update((existing as { id: string }).id, entryData);
+    } else {
+      await api.services.entries.create(entryData, 'system', 'Stripe Webhook');
+    }
+
+    api.logger.info(`Synced subscription: ${sub.id}`);
+  } catch (error) {
+    api.logger.error(`Failed to sync subscription ${sub.id}:`, error);
+  }
+}
+
+async function handleSubscriptionDeleted(sub: SubscriptionObject, api: PluginAPI): Promise<void> {
+  try {
+    const slug = toSlug(sub.id);
+    const existing = await api.services.entries.findBySlug(CT_SUBSCRIPTION, slug);
+    if (existing) {
+      await api.services.entries.update((existing as { id: string }).id, {
+        content: { status: 'canceled' },
+        status: 'archived',
+      });
+      api.logger.info(`Marked subscription as deleted: ${sub.id}`);
+    }
+  } catch (error) {
+    api.logger.error(`Failed to handle subscription deletion ${sub.id}:`, error);
+  }
+}
+
+async function syncInvoice(inv: InvoiceObject, api: PluginAPI): Promise<void> {
+  try {
+    const slug = toSlug(inv.id);
+    const existing = await api.services.entries.findBySlug(CT_INVOICE, slug);
+
+    const entryData = {
+      contentTypeSlug: CT_INVOICE,
+      title: inv.id,
+      slug,
+      content: {
+        stripeId: inv.id,
+        customerId: inv.customer,
+        subscriptionId: inv.subscription,
+        status: inv.status,
+        amountDue: inv.amount_due,
+        amountPaid: inv.amount_paid,
+        currency: inv.currency,
+        hostedInvoiceUrl: inv.hosted_invoice_url,
+        invoicePdf: inv.invoice_pdf,
+        paidAt: inv.status_transitions?.paid_at ? inv.status_transitions.paid_at * 1000 : null,
+      },
+      status: 'published',
+    };
+
+    if (existing) {
+      await api.services.entries.update((existing as { id: string }).id, entryData);
+    } else {
+      await api.services.entries.create(entryData, 'system', 'Stripe Webhook');
+    }
+
+    api.logger.info(`Synced invoice: ${inv.id}`);
+  } catch (error) {
+    api.logger.error(`Failed to sync invoice ${inv.id}:`, error);
+  }
+}
+
+async function handleCheckoutCompleted(checkout: CheckoutObject, api: PluginAPI): Promise<void> {
+  try {
+    // If there's a user ID, link the customer
+    if (checkout.client_reference_id && checkout.customer) {
+      const customerSlug = toSlug(checkout.customer);
+      const existing = await api.services.entries.findBySlug(
+        CT_CUSTOMER,
+        customerSlug
+      );
+
+      if (!existing && stripeService) {
+        const customer = await stripeService.getCustomer(checkout.customer);
+        if (customer) {
+          await api.services.entries.create({
+            contentTypeSlug: CT_CUSTOMER,
+            title: customer.email,
+            slug: toSlug(customer.id),
+            content: {
+              stripeId: customer.id,
+              email: customer.email,
+              name: customer.name,
+              userId: checkout.client_reference_id,
+              metadata: customer.metadata,
+            },
+            status: 'published',
+          }, 'system', 'Stripe Webhook');
+        }
+      }
+    }
+
+    api.logger.info(`Checkout completed: ${checkout.id}`);
+  } catch (error) {
+    api.logger.error(`Failed to handle checkout ${checkout.id}:`, error);
+  }
+}
+
+async function syncProduct(product: ProductObject, api: PluginAPI): Promise<void> {
+  try {
+    const slug = toSlug(product.id);
+    const existing = await api.services.entries.findBySlug(CT_PRODUCT, slug);
+
+    const entryData = {
+      contentTypeSlug: CT_PRODUCT,
+      title: product.name,
+      slug,
+      content: {
+        stripeId: product.id,
+        name: product.name,
+        description: product.description,
+        active: product.active,
+        metadata: product.metadata,
+      },
+      status: 'published',
+    };
+
+    if (existing) {
+      await api.services.entries.update((existing as { id: string }).id, entryData);
+    } else {
+      await api.services.entries.create(entryData, 'system', 'Stripe Webhook');
+    }
+
+    api.logger.info(`Synced product: ${product.id}`);
+  } catch (error) {
+    api.logger.error(`Failed to sync product ${product.id}:`, error);
+  }
+}
+
+async function syncPrice(price: PriceObject, api: PluginAPI): Promise<void> {
+  try {
+    const slug = toSlug(price.id);
+    const existing = await api.services.entries.findBySlug(CT_PRICE, slug);
+
+    const entryData = {
+      contentTypeSlug: CT_PRICE,
+      title: `${price.id} - ${price.unit_amount / 100} ${price.currency.toUpperCase()}`,
+      slug,
+      content: {
+        stripeId: price.id,
+        productId: price.product,
+        active: price.active,
+        currency: price.currency,
+        unitAmount: price.unit_amount,
+        type: price.type,
+        interval: price.recurring?.interval,
+        intervalCount: price.recurring?.interval_count,
+        trialPeriodDays: price.recurring?.trial_period_days,
+      },
+      status: 'published',
+    };
+
+    if (existing) {
+      await api.services.entries.update((existing as { id: string }).id, entryData);
+    } else {
+      await api.services.entries.create(entryData, 'system', 'Stripe Webhook');
+    }
+
+    api.logger.info(`Synced price: ${price.id}`);
+  } catch (error) {
+    api.logger.error(`Failed to sync price ${price.id}:`, error);
+  }
+}
+
+// ============================================================================
+// MCP Tools
+// ============================================================================
+
+function registerMCPTools(api: PluginAPI): void {
+  // Create checkout session
+  api.mcp.registerTool('create_checkout', {
+    description: 'Create a Stripe checkout session for payment or subscription',
+    inputSchema: CreateCheckoutSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof CreateCheckoutSchema>;
+      return await stripeService.createCheckoutSession({
+        priceId: params.priceId,
+        customerEmail: params.customerEmail,
+        customerId: params.customerId,
+        userId: params.userId,
+        mode: params.mode,
+        quantity: params.quantity,
+        trialPeriodDays: params.trialDays,
+      });
+    },
+  });
+
+  // Create customer portal
+  api.mcp.registerTool('create_portal', {
+    description: 'Create a Stripe customer portal session for subscription management',
+    inputSchema: CreatePortalSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof CreatePortalSchema>;
+      return await stripeService.createPortalSession({
+        customerId: params.customerId,
+        returnUrl: params.returnUrl,
+      });
+    },
+  });
+
+  // Get subscription
+  api.mcp.registerTool('get_subscription', {
+    description: 'Get details of a Stripe subscription',
+    inputSchema: GetSubscriptionSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof GetSubscriptionSchema>;
+      return await stripeService.getSubscription(params.subscriptionId);
+    },
+  });
+
+  // Cancel subscription
+  api.mcp.registerTool('cancel_subscription', {
+    description: 'Cancel a Stripe subscription',
+    inputSchema: CancelSubscriptionSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof CancelSubscriptionSchema>;
+      return await stripeService.cancelSubscription(params.subscriptionId, {
+        atPeriodEnd: params.atPeriodEnd,
+      });
+    },
+  });
+
+  // List products
+  api.mcp.registerTool('list_products', {
+    description: 'List Stripe products',
+    inputSchema: ListProductsSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof ListProductsSchema>;
+      return await stripeService.listProducts({
+        active: params.active,
+        limit: params.limit,
+      });
+    },
+  });
+
+  // List prices
+  api.mcp.registerTool('list_prices', {
+    description: 'List Stripe prices',
+    inputSchema: ListPricesSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof ListPricesSchema>;
+      return await stripeService.listPrices({
+        productId: params.productId,
+        active: params.active,
+        type: params.type,
+        limit: params.limit,
+      });
+    },
+  });
+
+  // List subscriptions
+  api.mcp.registerTool('list_subscriptions', {
+    description: 'List Stripe subscriptions',
+    inputSchema: ListSubscriptionsSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof ListSubscriptionsSchema>;
+      return await stripeService.listSubscriptions({
+        customerId: params.customerId,
+        status: params.status,
+        limit: params.limit,
+      });
+    },
+  });
+
+  // List invoices
+  api.mcp.registerTool('list_invoices', {
+    description: 'List Stripe invoices',
+    inputSchema: ListInvoicesSchema,
+    handler: async (args) => {
+      if (!stripeService) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof ListInvoicesSchema>;
+      return await stripeService.listInvoices({
+        customerId: params.customerId,
+        subscriptionId: params.subscriptionId,
+        status: params.status,
+        limit: params.limit,
+      });
+    },
+  });
+
+  // Sync products
+  api.mcp.registerTool('sync_products', {
+    description: 'Sync products from Stripe to LokiCMS content entries',
+    inputSchema: SyncProductsSchema,
+    handler: async (args) => {
+      if (!stripeService || !pluginApi) throw new Error('Stripe not configured');
+      const params = args as z.infer<typeof SyncProductsSchema>;
+      const products = await stripeService.listProducts({ active: params.active });
+      let synced = 0;
+
+      for (const product of products) {
+        try {
+          const slug = toSlug(product.id);
+          const existing = await pluginApi.services.entries.findBySlug(
+            CT_PRODUCT,
+            slug
+          );
+
+          const entryData = {
+            contentTypeSlug: CT_PRODUCT,
+            title: product.name,
+            slug,
+            content: {
+              stripeId: product.id,
+              name: product.name,
+              description: product.description,
+              active: product.active,
+              metadata: product.metadata,
+            },
+            status: 'published',
+          };
+
+          if (existing) {
+            await pluginApi.services.entries.update(
+              (existing as { id: string }).id,
+              entryData
+            );
+          } else {
+            await pluginApi.services.entries.create(entryData, 'system', 'MCP Sync');
+          }
+          synced++;
+        } catch {
+          // Continue with next product
+        }
+      }
+
+      return { synced, total: products.length };
+    },
+  });
+}
+
+export default stripePlugin;