palaryn 0.1.0 → 0.3.2

package/src/billing/plan-enforcer.ts

@@ -0,0 +1,135 @@
+import { Request, Response, NextFunction } from 'express';
+import { PlanTier, PLAN_LIMITS, PlanLimits } from '../types/subscription';
+import { WorkspaceStore, WorkspaceMemberStore, UserApiKeyStore } from '../storage/interfaces';
+
+export interface PlanEnforceResult {
+  allowed: boolean;
+  reason?: string;
+}
+
+export class PlanEnforcer {
+  static getLimits(plan: PlanTier): PlanLimits {
+    return PLAN_LIMITS[plan];
+  }
+
+  static checkCallLimit(plan: PlanTier, currentCount: number): { allowed: boolean; limit: number; current: number } {
+    const limits = PLAN_LIMITS[plan];
+    return {
+      allowed: currentCount < limits.calls_per_month,
+      limit: limits.calls_per_month,
+      current: currentCount,
+    };
+  }
+
+  static checkFeature(plan: PlanTier, feature: string): boolean {
+    return PLAN_LIMITS[plan].features.includes(feature);
+  }
+
+  /**
+   * Check if a workspace can add more members.
+   */
+  static checkMemberLimit(
+    plan: PlanTier,
+    currentMemberCount: number,
+  ): PlanEnforceResult {
+    const limits = PLAN_LIMITS[plan];
+    if (currentMemberCount >= limits.members_per_workspace) {
+      return {
+        allowed: false,
+        reason: `Plan "${plan}" allows a maximum of ${limits.members_per_workspace} members per workspace. Current: ${currentMemberCount}.`,
+      };
+    }
+    return { allowed: true };
+  }
+
+  /**
+   * Check if a workspace can create more API keys.
+   */
+  static checkApiKeyLimit(
+    plan: PlanTier,
+    currentKeyCount: number,
+  ): PlanEnforceResult {
+    const limits = PLAN_LIMITS[plan];
+    if (currentKeyCount >= limits.api_keys_per_workspace) {
+      return {
+        allowed: false,
+        reason: `Plan "${plan}" allows a maximum of ${limits.api_keys_per_workspace} API keys per workspace. Current: ${currentKeyCount}.`,
+      };
+    }
+    return { allowed: true };
+  }
+
+  /**
+   * Check if an org/user can create more workspaces.
+   */
+  static checkWorkspaceLimit(
+    plan: PlanTier,
+    currentWorkspaceCount: number,
+  ): PlanEnforceResult {
+    const limits = PLAN_LIMITS[plan];
+    if (currentWorkspaceCount >= limits.workspaces) {
+      return {
+        allowed: false,
+        reason: `Plan "${plan}" allows a maximum of ${limits.workspaces} workspaces. Current: ${currentWorkspaceCount}.`,
+      };
+    }
+    return { allowed: true };
+  }
+
+  // TODO: Integrate into gateway pipeline — call enforce() from gateway.preExecute()
+  // or wire createPlanEnforcerMiddleware() in src/server/app.ts before POST /v1/tool/execute.
+  /**
+   * Enforce call limits for a tool execution.
+   * Returns { allowed: true } or { allowed: false, reason: '...' }.
+   */
+  static enforce(plan: PlanTier, currentMonthlyCount: number): PlanEnforceResult {
+    const check = PlanEnforcer.checkCallLimit(plan, currentMonthlyCount);
+    if (!check.allowed) {
+      return {
+        allowed: false,
+        reason: `Monthly call limit reached for plan "${plan}": ${check.current}/${check.limit}. Upgrade your plan for more calls.`,
+      };
+    }
+    return { allowed: true };
+  }
+}
+
+/**
+ * Express middleware factory that enforces plan call limits before tool execution.
+ *
+ * Wire into app.ts:
+ *   app.post('/v1/tool/execute', createPlanEnforcerMiddleware(deps), executeHandler);
+ */
+export function createPlanEnforcerMiddleware(deps: {
+  workspaceStore: WorkspaceStore;
+  getMonthlyCallCount: (workspaceId: string) => number;
+}): (req: Request, res: Response, next: NextFunction) => void {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const workspaceId = req.body?.workspace_id || (req as any).workspace_id;
+    if (!workspaceId) {
+      next();
+      return;
+    }
+
+    const workspace = deps.workspaceStore.getById(workspaceId);
+    if (!workspace) {
+      next();
+      return;
+    }
+
+    const plan = (workspace.plan || 'free') as PlanTier;
+    const count = deps.getMonthlyCallCount(workspaceId);
+    const result = PlanEnforcer.enforce(plan, count);
+
+    if (!result.allowed) {
+      res.status(403).json({
+        error: result.reason,
+        error_code: 'PLAN_LIMIT_EXCEEDED',
+        hint: 'Upgrade your plan at /billing or wait until the next billing cycle.',
+      });
+      return;
+    }
+
+    next();
+  };
+}

package/src/billing/routes.ts

@@ -0,0 +1,229 @@
+import { Router, Request, Response } from 'express';
+import { StripeClient } from './stripe-client';
+import { PlanEnforcer } from './plan-enforcer';
+import { PlanTier, PLAN_LIMITS } from '../types/subscription';
+import { StripeConfig } from '../types/stripe-config';
+import {
+  SubscriptionStore,
+  WorkspaceStore,
+  WorkspaceMemberStore,
+} from '../storage/interfaces';
+import { Gateway } from '../server/gateway';
+
+export interface BillingRouteDeps {
+  stripeClient: StripeClient;
+  stripeConfig: StripeConfig;
+  subscriptionStore: SubscriptionStore;
+  workspaceStore: WorkspaceStore;
+  workspaceMemberStore: WorkspaceMemberStore;
+  gateway: Gateway;
+}
+
+/** Extract a route param as string (Express 5 returns string | string[]). */
+function param(req: Request, name: string): string {
+  const val = req.params[name];
+  return Array.isArray(val) ? val[0] : val;
+}
+
+function requireSession(req: Request, res: Response): boolean {
+  if (!(req as any).sessionUser) {
+    res.status(401).json({ error: 'Session authentication required' });
+    return false;
+  }
+  return true;
+}
+
+export function createBillingRouter(deps: BillingRouteDeps): Router {
+  const router = Router();
+  const { stripeClient, stripeConfig, subscriptionStore, workspaceStore, workspaceMemberStore, gateway } = deps;
+
+  // GET /workspaces/:id/billing - current plan + subscription status
+  router.get('/workspaces/:id/billing', (req: Request, res: Response) => {
+    if (!requireSession(req, res)) return;
+    const user = (req as any).sessionUser;
+    const workspaceId = param(req, 'id');
+
+    const membership = workspaceMemberStore.getByWorkspaceAndUser(workspaceId, user.id);
+    if (!membership) {
+      res.status(403).json({ error: 'Not a member of this workspace' });
+      return;
+    }
+
+    const workspace = workspaceStore.getById(workspaceId);
+    if (!workspace) {
+      res.status(404).json({ error: 'Workspace not found' });
+      return;
+    }
+
+    const subscription = subscriptionStore.getByWorkspace(workspaceId);
+    const plan = (workspace.plan || 'free') as PlanTier;
+    const limits = PlanEnforcer.getLimits(plan);
+
+    res.json({
+      plan,
+      limits,
+      subscription: subscription ? {
+        id: subscription.id,
+        status: subscription.status,
+        current_period_start: subscription.current_period_start,
+        current_period_end: subscription.current_period_end,
+        cancel_at_period_end: subscription.cancel_at_period_end,
+      } : null,
+    });
+  });
+
+  // POST /workspaces/:id/billing/checkout - create Stripe Checkout session
+  router.post('/workspaces/:id/billing/checkout', async (req: Request, res: Response) => {
+    if (!requireSession(req, res)) return;
+    const user = (req as any).sessionUser;
+    const workspaceId = param(req, 'id');
+
+    const membership = workspaceMemberStore.getByWorkspaceAndUser(workspaceId, user.id);
+    if (!membership || !['owner', 'admin'].includes(membership.role)) {
+      res.status(403).json({ error: 'Only workspace owners and admins can manage billing' });
+      return;
+    }
+
+    const { plan } = req.body;
+    if (!plan || !['pro', 'business'].includes(plan)) {
+      res.status(400).json({ error: 'plan must be "pro" or "business"' });
+      return;
+    }
+
+    const priceId = plan === 'pro'
+      ? stripeConfig.price_ids.pro_monthly
+      : stripeConfig.price_ids.business_monthly;
+
+    try {
+      // Get or create Stripe customer
+      let subscription = subscriptionStore.getByWorkspace(workspaceId);
+      let customerId: string;
+
+      if (subscription?.stripe_customer_id) {
+        customerId = subscription.stripe_customer_id;
+      } else {
+        const customer = await stripeClient.createCustomer(user.email, workspaceId, user.display_name);
+        customerId = customer.id;
+      }
+
+      const session = await stripeClient.createCheckoutSession(customerId, priceId, workspaceId);
+      res.json({ url: session.url });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Failed to create checkout session';
+      res.status(500).json({ error: message });
+    }
+  });
+
+  // POST /workspaces/:id/billing/portal - create Customer Portal session
+  router.post('/workspaces/:id/billing/portal', async (req: Request, res: Response) => {
+    if (!requireSession(req, res)) return;
+    const user = (req as any).sessionUser;
+    const workspaceId = param(req, 'id');
+
+    const membership = workspaceMemberStore.getByWorkspaceAndUser(workspaceId, user.id);
+    if (!membership || !['owner', 'admin'].includes(membership.role)) {
+      res.status(403).json({ error: 'Only workspace owners and admins can manage billing' });
+      return;
+    }
+
+    const subscription = subscriptionStore.getByWorkspace(workspaceId);
+    if (!subscription?.stripe_customer_id) {
+      res.status(400).json({ error: 'No billing account found. Subscribe to a plan first.' });
+      return;
+    }
+
+    try {
+      const session = await stripeClient.createPortalSession(subscription.stripe_customer_id);
+      res.json({ url: session.url });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Failed to create portal session';
+      res.status(500).json({ error: message });
+    }
+  });
+
+  // GET /workspaces/:id/billing/invoices - invoice history
+  router.get('/workspaces/:id/billing/invoices', async (req: Request, res: Response) => {
+    if (!requireSession(req, res)) return;
+    const user = (req as any).sessionUser;
+    const workspaceId = param(req, 'id');
+
+    const membership = workspaceMemberStore.getByWorkspaceAndUser(workspaceId, user.id);
+    if (!membership) {
+      res.status(403).json({ error: 'Not a member of this workspace' });
+      return;
+    }
+
+    const subscription = subscriptionStore.getByWorkspace(workspaceId);
+    if (!subscription?.stripe_customer_id) {
+      res.json({ invoices: [] });
+      return;
+    }
+
+    try {
+      const invoices = await stripeClient.getInvoices(subscription.stripe_customer_id);
+      res.json({
+        invoices: invoices.map(inv => ({
+          id: inv.id,
+          number: inv.number,
+          status: inv.status,
+          amount_due: inv.amount_due,
+          amount_paid: inv.amount_paid,
+          currency: inv.currency,
+          period_start: inv.period_start ? new Date(inv.period_start * 1000).toISOString() : null,
+          period_end: inv.period_end ? new Date(inv.period_end * 1000).toISOString() : null,
+          hosted_invoice_url: inv.hosted_invoice_url,
+          created: inv.created ? new Date(inv.created * 1000).toISOString() : null,
+        })),
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Failed to fetch invoices';
+      res.status(500).json({ error: message });
+    }
+  });
+
+  // GET /workspaces/:id/billing/usage - monthly call count vs limit
+  router.get('/workspaces/:id/billing/usage', (req: Request, res: Response) => {
+    if (!requireSession(req, res)) return;
+    const user = (req as any).sessionUser;
+    const workspaceId = param(req, 'id');
+
+    const membership = workspaceMemberStore.getByWorkspaceAndUser(workspaceId, user.id);
+    if (!membership) {
+      res.status(403).json({ error: 'Not a member of this workspace' });
+      return;
+    }
+
+    const workspace = workspaceStore.getById(workspaceId);
+    if (!workspace) {
+      res.status(404).json({ error: 'Workspace not found' });
+      return;
+    }
+
+    const plan = (workspace.plan || 'free') as PlanTier;
+
+    // Count events for this workspace in the current month
+    const allEvents = gateway.getAuditLogger().getAllEvents();
+    const now = new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const wsSlug = workspace.slug;
+
+    const monthlyCount = allEvents.filter(e => {
+      const matches = e.workspace_id === workspaceId || (wsSlug && e.workspace_id === wsSlug);
+      if (!matches) return false;
+      const eventDate = new Date(e.timestamp);
+      return eventDate >= monthStart;
+    }).length;
+
+    const check = PlanEnforcer.checkCallLimit(plan, monthlyCount);
+
+    res.json({
+      plan,
+      calls_this_month: monthlyCount,
+      calls_limit: check.limit,
+      allowed: check.allowed,
+      usage_percent: check.limit === Infinity ? 0 : Math.round((monthlyCount / check.limit) * 100),
+    });
+  });
+
+  return router;
+}

package/src/billing/stripe-client.ts

@@ -0,0 +1,58 @@
+import Stripe from 'stripe';
+import { StripeConfig } from '../types/stripe-config';
+
+export class StripeClient {
+  private stripe: Stripe;
+  private config: StripeConfig;
+
+  constructor(config: StripeConfig) {
+    this.stripe = new Stripe(config.secret_key);
+    this.config = config;
+  }
+
+  async createCustomer(email: string, workspaceId: string, name?: string): Promise<Stripe.Customer> {
+    return this.stripe.customers.create({
+      email,
+      name: name || undefined,
+      metadata: { workspace_id: workspaceId },
+    });
+  }
+
+  async createCheckoutSession(customerId: string, priceId: string, workspaceId: string): Promise<Stripe.Checkout.Session> {
+    return this.stripe.checkout.sessions.create({
+      customer: customerId,
+      mode: 'subscription',
+      line_items: [{ price: priceId, quantity: 1 }],
+      success_url: this.config.checkout_success_url || `${process.env.APP_BASE_URL || 'http://localhost:5173'}/billing?success=true&session_id={CHECKOUT_SESSION_ID}`,
+      cancel_url: this.config.checkout_cancel_url || `${process.env.APP_BASE_URL || 'http://localhost:5173'}/billing?canceled=true`,
+      metadata: { workspace_id: workspaceId },
+    });
+  }
+
+  async createPortalSession(customerId: string): Promise<Stripe.BillingPortal.Session> {
+    return this.stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: this.config.portal_return_url || undefined,
+    });
+  }
+
+  async getSubscription(subscriptionId: string): Promise<Stripe.Subscription> {
+    return this.stripe.subscriptions.retrieve(subscriptionId);
+  }
+
+  async getInvoices(customerId: string, limit: number = 10): Promise<Stripe.Invoice[]> {
+    const result = await this.stripe.invoices.list({
+      customer: customerId,
+      limit,
+    });
+    return result.data;
+  }
+
+  constructEvent(payload: Buffer, signature: string): Stripe.Event {
+    return this.stripe.webhooks.constructEvent(
+      payload,
+      signature,
+      this.config.webhook_secret,
+    );
+  }
+}

package/src/billing/webhook-handler.ts

@@ -0,0 +1,182 @@
+import Stripe from 'stripe';
+import { randomUUID } from 'crypto';
+import { SubscriptionStore, WorkspaceStore } from '../storage/interfaces';
+import { PlanTier } from '../types/subscription';
+import { StripeConfig } from '../types/stripe-config';
+
+export class WebhookHandler {
+  constructor(
+    private subscriptionStore: SubscriptionStore,
+    private workspaceStore: WorkspaceStore,
+    private config: StripeConfig,
+  ) {}
+
+  async handleEvent(event: Stripe.Event): Promise<void> {
+    switch (event.type) {
+      case 'checkout.session.completed':
+        await this.handleCheckoutCompleted(event.data.object as Stripe.Checkout.Session);
+        break;
+      case 'customer.subscription.updated':
+        await this.handleSubscriptionUpdated(event.data.object as Stripe.Subscription);
+        break;
+      case 'customer.subscription.deleted':
+        await this.handleSubscriptionDeleted(event.data.object as Stripe.Subscription);
+        break;
+      case 'invoice.payment_failed':
+        await this.handlePaymentFailed(event.data.object as Stripe.Invoice);
+        break;
+      case 'invoice.payment_succeeded':
+        await this.handlePaymentSucceeded(event.data.object as Stripe.Invoice);
+        break;
+    }
+  }
+
+  private resolvePlan(priceId: string): PlanTier {
+    if (priceId === this.config.price_ids.pro_monthly) return 'pro';
+    if (priceId === this.config.price_ids.business_monthly) return 'business';
+    return 'free';
+  }
+
+  private async handleCheckoutCompleted(session: Stripe.Checkout.Session): Promise<void> {
+    const workspaceId = session.metadata?.workspace_id;
+    if (!workspaceId || !session.subscription || !session.customer) return;
+
+    const subscriptionId = typeof session.subscription === 'string' ? session.subscription : session.subscription.id;
+    const customerId = typeof session.customer === 'string' ? session.customer : session.customer.id;
+
+    // Check for existing subscription by workspace (idempotency)
+    const existing = this.subscriptionStore.getByWorkspace(workspaceId);
+    if (existing && existing.stripe_subscription_id === subscriptionId) return;
+
+    // Resolve plan from the checkout session line items (stored in subscription)
+    // We need to determine plan from the price ID - use a default for now,
+    // the subscription.updated event will set the correct plan
+    const now = new Date().toISOString();
+
+    if (existing) {
+      // Update existing subscription
+      this.subscriptionStore.update(existing.id, {
+        stripe_subscription_id: subscriptionId,
+        stripe_customer_id: customerId,
+        status: 'active',
+        updated_at: now,
+      });
+    } else {
+      // Create new subscription record
+      this.subscriptionStore.create({
+        id: randomUUID(),
+        workspace_id: workspaceId,
+        stripe_customer_id: customerId,
+        stripe_subscription_id: subscriptionId,
+        plan: 'pro', // Default; subscription.updated will correct this
+        status: 'active',
+        created_at: now,
+        updated_at: now,
+      });
+    }
+  }
+
+  private async handleSubscriptionUpdated(subscription: Stripe.Subscription): Promise<void> {
+    const existing = this.subscriptionStore.getByStripeSubscriptionId(subscription.id);
+    if (!existing) return;
+
+    const now = new Date().toISOString();
+    // Guard: skip if our record is strictly newer than this event's creation timestamp
+    const eventCreatedAt = new Date(subscription.created * 1000).toISOString();
+    if (existing.updated_at > eventCreatedAt) return;
+
+    // Resolve plan from the first line item's price
+    const priceId = subscription.items?.data?.[0]?.price?.id;
+    const plan = priceId ? this.resolvePlan(priceId) : existing.plan;
+
+    const status = this.mapStripeStatus(subscription.status);
+
+    // Access period timestamps (Stripe SDK types vary across versions)
+    const subAny = subscription as any;
+    const periodStart = subAny.current_period_start;
+    const periodEnd = subAny.current_period_end;
+
+    this.subscriptionStore.update(existing.id, {
+      plan,
+      status,
+      current_period_start: periodStart ? new Date(periodStart * 1000).toISOString() : undefined,
+      current_period_end: periodEnd ? new Date(periodEnd * 1000).toISOString() : undefined,
+      cancel_at_period_end: subscription.cancel_at_period_end,
+      updated_at: now,
+    });
+
+    // Update workspace plan
+    this.workspaceStore.update(existing.workspace_id, {
+      plan,
+      updated_at: now,
+    });
+  }
+
+  private async handleSubscriptionDeleted(subscription: Stripe.Subscription): Promise<void> {
+    const existing = this.subscriptionStore.getByStripeSubscriptionId(subscription.id);
+    if (!existing) return;
+
+    const now = new Date().toISOString();
+
+    this.subscriptionStore.update(existing.id, {
+      status: 'canceled',
+      plan: 'free',
+      updated_at: now,
+    });
+
+    // Downgrade workspace to free
+    this.workspaceStore.update(existing.workspace_id, {
+      plan: 'free',
+      updated_at: now,
+    });
+  }
+
+  private getSubscriptionIdFromInvoice(invoice: Stripe.Invoice): string | undefined {
+    // Stripe SDK types vary across versions for invoice.subscription
+    const sub = (invoice as any).subscription;
+    if (!sub) return undefined;
+    return typeof sub === 'string' ? sub : sub.id;
+  }
+
+  private async handlePaymentFailed(invoice: Stripe.Invoice): Promise<void> {
+    const subscriptionId = this.getSubscriptionIdFromInvoice(invoice);
+    if (!subscriptionId) return;
+
+    const existing = this.subscriptionStore.getByStripeSubscriptionId(subscriptionId);
+    if (!existing) return;
+
+    this.subscriptionStore.update(existing.id, {
+      status: 'past_due',
+      updated_at: new Date().toISOString(),
+    });
+  }
+
+  private async handlePaymentSucceeded(invoice: Stripe.Invoice): Promise<void> {
+    const subscriptionId = this.getSubscriptionIdFromInvoice(invoice);
+    if (!subscriptionId) return;
+
+    const existing = this.subscriptionStore.getByStripeSubscriptionId(subscriptionId);
+    if (!existing) return;
+
+    if (existing.status === 'past_due' || existing.status === 'incomplete') {
+      this.subscriptionStore.update(existing.id, {
+        status: 'active',
+        updated_at: new Date().toISOString(),
+      });
+    }
+  }
+
+  private mapStripeStatus(status: Stripe.Subscription.Status): 'active' | 'past_due' | 'canceled' | 'trialing' | 'incomplete' {
+    switch (status) {
+      case 'active': return 'active';
+      case 'past_due': return 'past_due';
+      case 'canceled': return 'canceled';
+      case 'trialing': return 'trialing';
+      case 'incomplete': return 'incomplete';
+      case 'incomplete_expired': return 'canceled';
+      case 'unpaid': return 'past_due';
+      case 'paused': return 'canceled';
+      default: return 'active';
+    }
+  }
+}

package/src/billing/webhook-routes.ts

@@ -0,0 +1,28 @@
+import { Router, Request, Response } from 'express';
+import express from 'express';
+import { StripeClient } from './stripe-client';
+import { WebhookHandler } from './webhook-handler';
+
+export function createWebhookRouter(stripeClient: StripeClient, handler: WebhookHandler): Router {
+  const router = Router();
+
+  // IMPORTANT: Use express.raw() for Stripe signature verification
+  router.post('/stripe/webhook', express.raw({ type: 'application/json' }), async (req: Request, res: Response) => {
+    const sig = req.headers['stripe-signature'] as string;
+    if (!sig) {
+      res.status(400).json({ error: 'Missing stripe-signature header' });
+      return;
+    }
+
+    try {
+      const event = stripeClient.constructEvent(req.body, sig);
+      await handler.handleEvent(event);
+      res.json({ received: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Webhook signature verification failed';
+      res.status(400).json({ error: message });
+    }
+  });
+
+  return router;
+}