@nordsym/apiclaw 1.7.3 → 1.7.5

package/convex/stripeActions.ts

@@ -0,0 +1,512 @@
+import Stripe from "stripe";
+import { httpAction } from "./_generated/server";
+import { api } from "./_generated/api";
+
+// Initialize Stripe (will use env var at runtime)
+function getStripe(): Stripe {
+  const key = process.env.STRIPE_SECRET_KEY;
+  if (!key) {
+    throw new Error("STRIPE_SECRET_KEY not configured");
+  }
+  return new Stripe(key);
+}
+
+// CORS headers
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization, stripe-signature",
+};
+
+function jsonResponse(data: unknown, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...corsHeaders },
+  });
+}
+
+/**
+ * Create Stripe Checkout Session
+ * POST /api/billing/checkout
+ */
+export const createCheckoutSession = httpAction(async (ctx, request) => {
+  try {
+    const body = await request.json();
+    const { workspaceId, returnUrl, mode = "setup" } = body;
+
+    if (!workspaceId) {
+      return jsonResponse({ error: "workspaceId required" }, 400);
+    }
+
+    const stripe = getStripe();
+
+    // Get workspace
+    const workspace = await ctx.runQuery(api.billing.getWorkspace, {
+      id: workspaceId,
+    });
+
+    if (!workspace) {
+      return jsonResponse({ error: "Workspace not found" }, 404);
+    }
+
+    let customerId = workspace.stripeCustomerId;
+
+    // Create Stripe customer if doesn't exist
+    if (!customerId) {
+      const customer = await stripe.customers.create({
+        email: workspace.email,
+        metadata: {
+          workspaceId: workspaceId,
+          source: "apiclaw",
+        },
+      });
+      customerId = customer.id;
+
+      // Link customer to workspace
+      await ctx.runMutation(api.billing.linkCustomer, {
+        workspaceId: workspaceId,
+        stripeCustomerId: customerId,
+      });
+    }
+
+    const baseUrl = returnUrl || "https://apiclaw.nordsym.com";
+
+    // Create checkout session
+    if (mode === "setup") {
+      // Setup mode - just save card for future billing
+      const session = await stripe.checkout.sessions.create({
+        customer: customerId,
+        mode: "setup",
+        payment_method_types: ["card"],
+        success_url: `${baseUrl}/billing?session_id={CHECKOUT_SESSION_ID}&success=true`,
+        cancel_url: `${baseUrl}/billing?canceled=true`,
+        metadata: {
+          workspaceId: workspaceId,
+        },
+      });
+
+      return jsonResponse({
+        checkoutUrl: session.url,
+        sessionId: session.id,
+      });
+    } else if (mode === "subscription") {
+      // Create metered subscription
+      const priceId = process.env.STRIPE_PRICE_ID_USAGE;
+      if (!priceId) {
+        return jsonResponse({ error: "Usage price not configured" }, 500);
+      }
+
+      const session = await stripe.checkout.sessions.create({
+        customer: customerId,
+        mode: "subscription",
+        line_items: [
+          {
+            price: priceId,
+          },
+        ],
+        success_url: `${baseUrl}/billing?session_id={CHECKOUT_SESSION_ID}&success=true`,
+        cancel_url: `${baseUrl}/billing?canceled=true`,
+        metadata: {
+          workspaceId: workspaceId,
+        },
+      });
+
+      return jsonResponse({
+        checkoutUrl: session.url,
+        sessionId: session.id,
+      });
+    } else {
+      return jsonResponse({ error: "Invalid mode. Use 'setup' or 'subscription'" }, 400);
+    }
+  } catch (e: any) {
+    console.error("Checkout error:", e);
+    return jsonResponse({ error: e.message || "Failed to create checkout" }, 500);
+  }
+});
+
+/**
+ * Create Stripe Billing Portal Session
+ * POST /api/billing/portal
+ */
+export const createPortalSession = httpAction(async (ctx, request) => {
+  try {
+    const body = await request.json();
+    const { workspaceId, returnUrl } = body;
+
+    if (!workspaceId) {
+      return jsonResponse({ error: "workspaceId required" }, 400);
+    }
+
+    const stripe = getStripe();
+
+    // Get workspace
+    const workspace = await ctx.runQuery(api.billing.getWorkspace, {
+      id: workspaceId,
+    });
+
+    if (!workspace) {
+      return jsonResponse({ error: "Workspace not found" }, 404);
+    }
+
+    if (!workspace.stripeCustomerId) {
+      return jsonResponse(
+        { error: "No billing account. Add a payment method first." },
+        400
+      );
+    }
+
+    const session = await stripe.billingPortal.sessions.create({
+      customer: workspace.stripeCustomerId,
+      return_url: returnUrl || "https://apiclaw.com/workspace?tab=settings&portal=success",
+    });
+
+    return jsonResponse({
+      portalUrl: session.url,
+    });
+  } catch (e: any) {
+    console.error("Portal error:", e);
+    return jsonResponse({ error: e.message || "Failed to create portal session" }, 500);
+  }
+});
+
+/**
+ * Stripe Webhook Handler
+ * POST /api/webhooks/stripe
+ */
+export const handleStripeWebhook = httpAction(async (ctx, request) => {
+  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+  if (!webhookSecret) {
+    console.error("STRIPE_WEBHOOK_SECRET not configured");
+    return jsonResponse({ error: "Webhook not configured" }, 500);
+  }
+
+  const stripe = getStripe();
+  const signature = request.headers.get("stripe-signature");
+
+  if (!signature) {
+    return jsonResponse({ error: "Missing stripe-signature header" }, 400);
+  }
+
+  let event: Stripe.Event;
+
+  try {
+    const body = await request.text();
+    event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  } catch (err: any) {
+    console.error("Webhook signature verification failed:", err.message);
+    return jsonResponse({ error: `Webhook Error: ${err.message}` }, 400);
+  }
+
+  // Handle the event
+  try {
+    switch (event.type) {
+      case "checkout.session.completed": {
+        const session = event.data.object as Stripe.Checkout.Session;
+        await handleCheckoutComplete(ctx, session);
+        break;
+      }
+
+      case "customer.subscription.created":
+      case "customer.subscription.updated": {
+        const subscription = event.data.object as Stripe.Subscription;
+        await handleSubscriptionUpdate(ctx, subscription);
+        break;
+      }
+
+      case "customer.subscription.deleted": {
+        const subscription = event.data.object as Stripe.Subscription;
+        await handleSubscriptionCanceled(ctx, subscription);
+        break;
+      }
+
+      case "invoice.paid": {
+        const invoice = event.data.object as Stripe.Invoice;
+        await handleInvoicePaid(ctx, invoice);
+        break;
+      }
+
+      case "invoice.payment_failed": {
+        const invoice = event.data.object as Stripe.Invoice;
+        await handlePaymentFailed(ctx, invoice);
+        break;
+      }
+
+      case "setup_intent.succeeded": {
+        const setupIntent = event.data.object as Stripe.SetupIntent;
+        await handleSetupSuccess(ctx, setupIntent);
+        break;
+      }
+
+      case "payment_method.attached": {
+        const paymentMethod = event.data.object as Stripe.PaymentMethod;
+        await handlePaymentMethodAttached(ctx, paymentMethod);
+        break;
+      }
+
+      case "payment_method.detached": {
+        const paymentMethod = event.data.object as Stripe.PaymentMethod;
+        await handlePaymentMethodDetached(ctx, paymentMethod);
+        break;
+      }
+
+      default:
+        console.log(`Unhandled event type: ${event.type}`);
+    }
+
+    return jsonResponse({ received: true, type: event.type });
+  } catch (e: any) {
+    console.error(`Error handling ${event.type}:`, e);
+    // Return 200 to prevent Stripe retries for business logic errors
+    return jsonResponse({ received: true, error: e.message });
+  }
+});
+
+// ============================================
+// Webhook Event Handlers
+// ============================================
+
+async function handleCheckoutComplete(
+  ctx: any,
+  session: Stripe.Checkout.Session
+) {
+  const workspaceId = session.metadata?.workspaceId;
+  if (!workspaceId) {
+    console.log("No workspaceId in checkout session metadata");
+    return;
+  }
+
+  // If subscription mode, the subscription webhook will handle it
+  if (session.mode === "subscription" && session.subscription) {
+    console.log("Subscription checkout completed, waiting for subscription webhook");
+    return;
+  }
+
+  // If setup mode, upgrade to usage-based billing
+  if (session.mode === "setup") {
+    await ctx.runMutation(api.billing.updateSubscription, {
+      workspaceId: workspaceId,
+      billingPlan: "usage_based",
+    });
+    console.log(`Workspace ${workspaceId} upgraded to usage-based billing`);
+  }
+}
+
+async function handleSubscriptionUpdate(
+  ctx: any,
+  subscription: Stripe.Subscription
+) {
+  const customerId =
+    typeof subscription.customer === "string"
+      ? subscription.customer
+      : subscription.customer.id;
+
+  // Get workspace by customer ID
+  const workspace = await ctx.runQuery(api.billing.getByStripeCustomerId, {
+    stripeCustomerId: customerId,
+  });
+
+  if (!workspace) {
+    console.log(`No workspace found for customer ${customerId}`);
+    return;
+  }
+
+  // Determine plan from subscription
+  const plan = subscription.status === "active" ? "usage_based" : "free";
+
+  await ctx.runMutation(api.billing.updateSubscription, {
+    workspaceId: workspace._id,
+    stripeSubscriptionId: subscription.id,
+    billingPlan: plan,
+  });
+
+  console.log(`Subscription ${subscription.id} updated for workspace ${workspace._id}`);
+}
+
+async function handleSubscriptionCanceled(
+  ctx: any,
+  subscription: Stripe.Subscription
+) {
+  const customerId =
+    typeof subscription.customer === "string"
+      ? subscription.customer
+      : subscription.customer.id;
+
+  const workspace = await ctx.runQuery(api.billing.getByStripeCustomerId, {
+    stripeCustomerId: customerId,
+  });
+
+  if (!workspace) {
+    console.log(`No workspace found for customer ${customerId}`);
+    return;
+  }
+
+  // Downgrade to free and reset usage
+  await ctx.runMutation(api.billing.updateSubscription, {
+    workspaceId: workspace._id,
+    stripeSubscriptionId: undefined,
+    billingPlan: "free",
+  });
+
+  // Reset usage count to 0 for clean slate on free tier
+  await ctx.runMutation(api.billing.resetUsageOnCancellation, {
+    workspaceId: workspace._id,
+  });
+
+  console.log(`Workspace ${workspace._id} downgraded to free (subscription canceled)`);
+}
+
+async function handleInvoicePaid(ctx: any, invoice: Stripe.Invoice) {
+  const customerId =
+    typeof invoice.customer === "string"
+      ? invoice.customer
+      : invoice.customer?.id;
+
+  if (!customerId) return;
+
+  const workspace = await ctx.runQuery(api.billing.getByStripeCustomerId, {
+    stripeCustomerId: customerId,
+  });
+
+  if (!workspace) {
+    console.log(`No workspace found for customer ${customerId}`);
+    return;
+  }
+
+  // Calculate call count from line items (for metered billing)
+  let callCount = 0;
+  if (invoice.lines?.data) {
+    for (const line of invoice.lines.data) {
+      if (line.quantity) {
+        callCount += line.quantity;
+      }
+    }
+  }
+
+  await ctx.runMutation(api.billing.processPayment, {
+    stripeInvoiceId: invoice.id,
+    workspaceId: workspace._id,
+    amount: invoice.amount_paid,
+    periodStart: invoice.period_start * 1000,
+    periodEnd: invoice.period_end * 1000,
+    callCount,
+    pdfUrl: invoice.invoice_pdf || undefined,
+  });
+
+  console.log(`Invoice ${invoice.id} processed for workspace ${workspace._id}`);
+}
+
+async function handlePaymentFailed(ctx: any, invoice: Stripe.Invoice) {
+  const customerId =
+    typeof invoice.customer === "string"
+      ? invoice.customer
+      : invoice.customer?.id;
+
+  if (!customerId) return;
+
+  // Update invoice status to failed
+  await ctx.runMutation(api.billing.updateInvoiceStatus, {
+    stripeInvoiceId: invoice.id,
+    status: "failed",
+  });
+
+  console.log(`Payment failed for invoice ${invoice.id}`);
+
+  // TODO: Send notification to user about failed payment
+}
+
+async function handleSetupSuccess(
+  ctx: any,
+  setupIntent: Stripe.SetupIntent
+) {
+  // Card saved successfully
+  const customerId =
+    typeof setupIntent.customer === "string"
+      ? setupIntent.customer
+      : setupIntent.customer?.id;
+
+  if (!customerId) return;
+
+  const workspace = await ctx.runQuery(api.billing.getByStripeCustomerId, {
+    stripeCustomerId: customerId,
+  });
+
+  if (!workspace) {
+    console.log(`No workspace found for customer ${customerId}`);
+    return;
+  }
+
+  // Upgrade to usage-based if still on free
+  if (!workspace.billingPlan || workspace.billingPlan === "free") {
+    await ctx.runMutation(api.billing.updateSubscription, {
+      workspaceId: workspace._id,
+      billingPlan: "usage_based",
+    });
+    console.log(`Workspace ${workspace._id} upgraded after setup intent`);
+  }
+}
+
+async function handlePaymentMethodAttached(
+  ctx: any,
+  paymentMethod: Stripe.PaymentMethod
+) {
+  // Payment method attached to customer
+  const customerId =
+    typeof paymentMethod.customer === "string"
+      ? paymentMethod.customer
+      : paymentMethod.customer?.id;
+
+  if (!customerId) {
+    console.log("Payment method attached but no customer ID");
+    return;
+  }
+
+  const workspace = await ctx.runQuery(api.billing.getByStripeCustomerId, {
+    stripeCustomerId: customerId,
+  });
+
+  if (!workspace) {
+    console.log(`No workspace found for customer ${customerId}`);
+    return;
+  }
+
+  // Sync payment method info
+  await ctx.runMutation(api.billing.updatePaymentMethodInfo, {
+    workspaceId: workspace._id,
+    hasPaymentMethod: true,
+    paymentMethodType: paymentMethod.type,
+    cardBrand: paymentMethod.card?.brand,
+    cardLast4: paymentMethod.card?.last4,
+  });
+
+  console.log(`Payment method attached for workspace ${workspace._id}`);
+}
+
+async function handlePaymentMethodDetached(
+  ctx: any,
+  paymentMethod: Stripe.PaymentMethod
+) {
+  // When a payment method is detached, we need to check if customer still has payment methods
+  // Since customer info isn't available on detached event, we log it
+  console.log(`Payment method ${paymentMethod.id} detached`);
+  
+  // Note: In a production system, you might want to:
+  // 1. Query Stripe for remaining payment methods
+  // 2. If no payment methods remain, downgrade the workspace
+  // For now, we rely on subscription cancellation to handle downgrades
+}
+
+// ============================================
+// OPTIONS handlers for CORS
+// ============================================
+
+export const checkoutOptions = httpAction(async () => {
+  return new Response(null, { headers: corsHeaders });
+});
+
+export const portalOptions = httpAction(async () => {
+  return new Response(null, { headers: corsHeaders });
+});
+
+export const webhookOptions = httpAction(async () => {
+  return new Response(null, { headers: corsHeaders });
+});

package/convex/teams.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get team members for a workspace
+ */
+export declare const getMembers: any;
+/**
+ * Invite a member to the workspace (creates pending invite)
+ */
+export declare const inviteMember: any;
+/**
+ * Accept an invite
+ */
+export declare const acceptInvite: any;
+/**
+ * Remove a member from the workspace
+ */
+export declare const removeMember: any;
+/**
+ * Get invite details (public, for invite acceptance page)
+ */
+export declare const getInviteDetails: any;
+//# sourceMappingURL=teams.d.ts.map

package/convex/teams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teams.d.ts","sourceRoot":"","sources":["teams.ts"],"names":[],"mappings":"AAoBA;;GAEG;AACH,eAAO,MAAM,UAAU,KAuCrB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,YAAY,KAoEvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,KA2BvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,KAwCvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB,KAqB3B,CAAC"}