@nordsym/apiclaw 1.3.6 → 1.3.7

package/convex/billing.ts

@@ -1,230 +1,319 @@
 import { v } from "convex/values";
-import { mutation, query, action } from "./_generated/server";
-import { api } from "./_generated/api";
-
-// Tier limits
-const TIER_LIMITS: Record<string, number> = {
-  free: 100,      // 100 API calls/month
-  pro: 10000,     // 10k API calls/month
-  enterprise: -1, // unlimited
-};
+import { mutation, query, internalMutation, internalAction, internalQuery } from "./_generated/server";
+import { Id } from "./_generated/dataModel";
+import { internal } from "./_generated/api";
+import Stripe from "stripe";
+
+// Initialize Stripe
+function getStripe(): Stripe {
+  const key = process.env.STRIPE_SECRET_KEY;
+  if (!key) {
+    throw new Error("STRIPE_SECRET_KEY not configured");
+  }
+  return new Stripe(key);
+}
 
 // ============================================
-// STRIPE CUSTOMER MANAGEMENT
+// MUTATIONS
 // ============================================
 
-// Create Stripe customer for workspace
-export const createStripeCustomer = action({
+/**
+ * Link a Stripe customer to a workspace
+ */
+export const linkCustomer = mutation({
   args: {
     workspaceId: v.id("workspaces"),
+    stripeCustomerId: v.string(),
   },
-  handler: async (ctx, args): Promise<{ success: boolean; customerId?: string; error?: string }> => {
-    const stripeSecretKey = process.env.STRIPE_SECRET_KEY;
-    if (!stripeSecretKey) {
-      return { success: false, error: "Stripe not configured" };
+  handler: async (ctx, args) => {
+    const workspace = await ctx.db.get(args.workspaceId);
+    if (!workspace) {
+      throw new Error("Workspace not found");
     }
 
-    // Get workspace
-    const workspace = await ctx.runQuery(api.billing.getWorkspace, { 
-      workspaceId: args.workspaceId 
+    await ctx.db.patch(args.workspaceId, {
+      stripeCustomerId: args.stripeCustomerId,
+      updatedAt: Date.now(),
     });
-    
+
+    return { success: true };
+  },
+});
+
+/**
+ * Update subscription status for a workspace
+ */
+export const updateSubscription = mutation({
+  args: {
+    workspaceId: v.id("workspaces"),
+    stripeSubscriptionId: v.optional(v.string()),
+    billingPlan: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const workspace = await ctx.db.get(args.workspaceId);
     if (!workspace) {
-      return { success: false, error: "Workspace not found" };
+      throw new Error("Workspace not found");
     }
 
-    // Check if already has customer
-    if (workspace.stripeCustomerId) {
-      return { success: true, customerId: workspace.stripeCustomerId };
-    }
+    // Update tier and usage limit based on plan
+    const planLimits: Record<string, number> = {
+      free: 100,
+      usage_based: 999999999, // Effectively unlimited
+      starter: 1000,
+      pro: 10000,
+      scale: 100000,
+    };
 
-    try {
-      // Create Stripe customer
-      const response = await fetch("https://api.stripe.com/v1/customers", {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${stripeSecretKey}`,
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-        body: new URLSearchParams({
-          email: workspace.email,
-          "metadata[workspaceId]": args.workspaceId,
-          "metadata[source]": "apiclaw",
-        }),
-      });
+    const newLimit = planLimits[args.billingPlan] || 100;
 
-      const customer = await response.json() as { id: string; error?: { message: string } };
-      
-      if (!response.ok || customer.error) {
-        return { success: false, error: customer.error?.message || "Failed to create customer" };
-      }
+    await ctx.db.patch(args.workspaceId, {
+      stripeSubscriptionId: args.stripeSubscriptionId,
+      billingPlan: args.billingPlan,
+      tier: args.billingPlan === "free" ? "free" : "pro",
+      usageLimit: newLimit,
+      updatedAt: Date.now(),
+    });
 
-      // Save customer ID to workspace
-      await ctx.runMutation(api.billing.saveStripeCustomerId, {
+    return { success: true, newLimit };
+  },
+});
+
+/**
+ * Record daily usage for billing
+ */
+export const recordUsage = mutation({
+  args: {
+    workspaceId: v.id("workspaces"),
+    callCount: v.number(),
+    date: v.string(), // "2026-02-28" format
+  },
+  handler: async (ctx, args) => {
+    // Check if record exists for this date
+    const existing = await ctx.db
+      .query("usageRecords")
+      .withIndex("by_workspaceId_date", (q) =>
+        q.eq("workspaceId", args.workspaceId).eq("date", args.date)
+      )
+      .unique();
+
+    if (existing) {
+      // Update existing record
+      await ctx.db.patch(existing._id, {
+        callCount: existing.callCount + args.callCount,
+        updatedAt: Date.now(),
+      });
+      return { id: existing._id, callCount: existing.callCount + args.callCount };
+    } else {
+      // Create new record
+      const id = await ctx.db.insert("usageRecords", {
         workspaceId: args.workspaceId,
-        stripeCustomerId: customer.id,
+        date: args.date,
+        callCount: args.callCount,
+        reportedToStripe: false,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
       });
-
-      return { success: true, customerId: customer.id };
-    } catch (error) {
-      return { success: false, error: String(error) };
+      return { id, callCount: args.callCount };
     }
   },
 });
 
-// Internal: Save Stripe customer ID to workspace
-export const saveStripeCustomerId = mutation({
+/**
+ * Process a successful payment (from webhook)
+ */
+export const processPayment = mutation({
   args: {
+    stripeInvoiceId: v.string(),
     workspaceId: v.id("workspaces"),
-    stripeCustomerId: v.string(),
+    amount: v.number(), // in cents
+    periodStart: v.number(),
+    periodEnd: v.number(),
+    callCount: v.number(),
+    pdfUrl: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
+    // Check for idempotency - don't process same invoice twice
+    const existing = await ctx.db
+      .query("invoices")
+      .withIndex("by_stripeInvoiceId", (q) =>
+        q.eq("stripeInvoiceId", args.stripeInvoiceId)
+      )
+      .unique();
+
+    if (existing) {
+      // Already processed, return existing
+      return { id: existing._id, alreadyProcessed: true };
+    }
+
+    // Create invoice record
+    const id = await ctx.db.insert("invoices", {
+      workspaceId: args.workspaceId,
+      stripeInvoiceId: args.stripeInvoiceId,
+      amount: args.amount,
+      status: "paid",
+      periodStart: args.periodStart,
+      periodEnd: args.periodEnd,
+      callCount: args.callCount,
+      pdfUrl: args.pdfUrl,
+      createdAt: Date.now(),
+    });
+
+    // Update workspace last billing date
     await ctx.db.patch(args.workspaceId, {
-      stripeCustomerId: args.stripeCustomerId,
+      lastBillingDate: Date.now(),
       updatedAt: Date.now(),
     });
+
+    return { id, alreadyProcessed: false };
   },
 });
 
-// Query workspace (for actions)
-export const getWorkspace = query({
+/**
+ * Increment credit balance (for prepaid credits)
+ */
+export const incrementCredits = mutation({
   args: {
     workspaceId: v.id("workspaces"),
+    amount: v.number(), // in cents
   },
   handler: async (ctx, args) => {
-    return await ctx.db.get(args.workspaceId);
+    const workspace = await ctx.db.get(args.workspaceId);
+    if (!workspace) {
+      throw new Error("Workspace not found");
+    }
+
+    const currentBalance = workspace.creditBalance || 0;
+    const newBalance = currentBalance + args.amount;
+
+    await ctx.db.patch(args.workspaceId, {
+      creditBalance: newBalance,
+      updatedAt: Date.now(),
+    });
+
+    return { previousBalance: currentBalance, newBalance };
   },
 });
 
-// ============================================
-// CHECKOUT SESSION (Add Payment Method)
-// ============================================
-
-// Create checkout session for subscription
-export const createCheckoutSession = action({
+/**
+ * Decrement credit balance (when using prepaid credits)
+ */
+export const decrementCredits = mutation({
   args: {
     workspaceId: v.id("workspaces"),
-    successUrl: v.string(),
-    cancelUrl: v.string(),
+    amount: v.number(), // in cents
   },
-  handler: async (ctx, args): Promise<{ success: boolean; sessionId?: string; url?: string; error?: string }> => {
-    const stripeSecretKey = process.env.STRIPE_SECRET_KEY;
-    if (!stripeSecretKey) {
-      return { success: false, error: "Stripe not configured" };
-    }
-
-    // Get workspace
-    const workspace = await ctx.runQuery(api.billing.getWorkspace, { 
-      workspaceId: args.workspaceId 
-    });
-    
+  handler: async (ctx, args) => {
+    const workspace = await ctx.db.get(args.workspaceId);
     if (!workspace) {
-      return { success: false, error: "Workspace not found" };
+      throw new Error("Workspace not found");
     }
 
-    // Create customer if needed
-    let customerId = workspace.stripeCustomerId;
-    if (!customerId) {
-      const result = await ctx.runAction(api.billing.createStripeCustomer, {
-        workspaceId: args.workspaceId,
-      });
-      if (!result.success || !result.customerId) {
-        return { success: false, error: result.error || "Failed to create customer" };
-      }
-      customerId = result.customerId;
+    const currentBalance = workspace.creditBalance || 0;
+    if (currentBalance < args.amount) {
+      throw new Error("Insufficient credit balance");
     }
 
-    try {
-      // Create checkout session for Pro subscription
-      // Using the existing APIClaw Pro price
-      const response = await fetch("https://api.stripe.com/v1/checkout/sessions", {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${stripeSecretKey}`,
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-        body: new URLSearchParams({
-          customer: customerId,
-          mode: "subscription",
-          "line_items[0][price]": "price_1T1OC2RtJYK3aJTqlJZskgtP", // APIClaw Pro $99/month
-          "line_items[0][quantity]": "1",
-          success_url: args.successUrl,
-          cancel_url: args.cancelUrl,
-          "metadata[workspaceId]": args.workspaceId,
-          "metadata[type]": "upgrade_pro",
-        }),
-      });
+    const newBalance = currentBalance - args.amount;
 
-      const session = await response.json() as { 
-        id: string; 
-        url: string;
-        error?: { message: string } 
-      };
-      
-      if (!response.ok || session.error) {
-        return { success: false, error: session.error?.message || "Failed to create session" };
-      }
+    await ctx.db.patch(args.workspaceId, {
+      creditBalance: newBalance,
+      updatedAt: Date.now(),
+    });
 
-      return { 
-        success: true, 
-        sessionId: session.id,
-        url: session.url,
-      };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
+    return { previousBalance: currentBalance, newBalance };
   },
 });
 
-// ============================================
-// WORKSPACE UPGRADE
-// ============================================
+/**
+ * Mark usage as reported to Stripe
+ */
+export const markUsageReported = internalMutation({
+  args: {
+    usageRecordId: v.id("usageRecords"),
+    stripeUsageRecordId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.usageRecordId, {
+      reportedToStripe: true,
+      stripeUsageRecordId: args.stripeUsageRecordId,
+      updatedAt: Date.now(),
+    });
+  },
+});
 
-// Upgrade workspace to paid tier
-export const upgradeWorkspace = mutation({
+/**
+ * Update invoice status (from webhook)
+ */
+export const updateInvoiceStatus = mutation({
+  args: {
+    stripeInvoiceId: v.string(),
+    status: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const invoice = await ctx.db
+      .query("invoices")
+      .withIndex("by_stripeInvoiceId", (q) =>
+        q.eq("stripeInvoiceId", args.stripeInvoiceId)
+      )
+      .unique();
+
+    if (!invoice) {
+      return { found: false };
+    }
+
+    await ctx.db.patch(invoice._id, {
+      status: args.status,
+    });
+
+    return { found: true, id: invoice._id };
+  },
+});
+
+/**
+ * Reset usage count on subscription cancellation
+ * Gives user a clean slate when downgrading to free
+ */
+export const resetUsageOnCancellation = mutation({
   args: {
     workspaceId: v.id("workspaces"),
-    tier: v.optional(v.string()),
-    stripeSubscriptionId: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
     const workspace = await ctx.db.get(args.workspaceId);
     if (!workspace) {
-      return { success: false, error: "workspace_not_found" };
+      throw new Error("Workspace not found");
     }
 
-    const newTier = args.tier || "pro";
-    const newLimit = TIER_LIMITS[newTier] || TIER_LIMITS.pro;
-
     await ctx.db.patch(args.workspaceId, {
-      tier: newTier,
-      usageLimit: newLimit,
-      status: "active",
+      usageCount: 0,
       updatedAt: Date.now(),
     });
 
-    return { 
-      success: true,
-      tier: newTier,
-      usageLimit: newLimit,
-    };
+    return { success: true, previousUsage: workspace.usageCount };
   },
 });
 
-// Suspend workspace (e.g., payment failed)
-export const suspendWorkspace = mutation({
+/**
+ * Update payment method info (from webhook)
+ */
+export const updatePaymentMethodInfo = mutation({
   args: {
     workspaceId: v.id("workspaces"),
-    reason: v.optional(v.string()),
+    hasPaymentMethod: v.boolean(),
+    paymentMethodType: v.optional(v.string()),
+    cardBrand: v.optional(v.string()),
+    cardLast4: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
     const workspace = await ctx.db.get(args.workspaceId);
     if (!workspace) {
-      return { success: false, error: "workspace_not_found" };
+      throw new Error("Workspace not found");
     }
 
     await ctx.db.patch(args.workspaceId, {
-      status: "suspended",
+      hasPaymentMethod: args.hasPaymentMethod,
+      paymentMethodType: args.paymentMethodType,
+      cardBrand: args.cardBrand,
+      cardLast4: args.cardLast4,
       updatedAt: Date.now(),
     });
 
@@ -232,110 +321,456 @@ export const suspendWorkspace = mutation({
   },
 });
 
-// Get workspace by Stripe customer ID (for webhooks)
-export const getWorkspaceByStripeCustomer = query({
+// ============================================
+// QUERIES
+// ============================================
+
+/**
+ * Get billing info for a workspace
+ */
+export const getInfo = query({
   args: {
-    stripeCustomerId: v.string(),
+    workspaceId: v.id("workspaces"),
   },
   handler: async (ctx, args) => {
-    return await ctx.db
-      .query("workspaces")
-      .withIndex("by_stripeCustomerId", (q) => q.eq("stripeCustomerId", args.stripeCustomerId))
-      .first();
+    const workspace = await ctx.db.get(args.workspaceId);
+    if (!workspace) {
+      throw new Error("Workspace not found");
+    }
+
+    // Get recent invoices
+    const invoices = await ctx.db
+      .query("invoices")
+      .withIndex("by_workspaceId_createdAt", (q) =>
+        q.eq("workspaceId", args.workspaceId)
+      )
+      .order("desc")
+      .take(10);
+
+    // Calculate current period usage
+    const now = new Date();
+    const periodStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const periodStartStr = periodStart.toISOString().split("T")[0];
+
+    const usageRecords = await ctx.db
+      .query("usageRecords")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId))
+      .collect();
+
+    const currentPeriodUsage = usageRecords
+      .filter((r) => r.date >= periodStartStr)
+      .reduce((sum, r) => sum + r.callCount, 0);
+
+    // Determine plan limits
+    const plan = workspace.billingPlan || "free";
+    const planLimits: Record<string, number> = {
+      free: 100,
+      usage_based: 999999999,
+      starter: 1000,
+      pro: 10000,
+      scale: 100000,
+    };
+
+    return {
+      plan,
+      tier: workspace.tier,
+      usage: workspace.usageCount,
+      currentPeriodUsage,
+      limit: workspace.usageLimit,
+      creditBalance: workspace.creditBalance || 0,
+      stripeCustomerId: workspace.stripeCustomerId,
+      stripeSubscriptionId: workspace.stripeSubscriptionId,
+      lastBillingDate: workspace.lastBillingDate,
+      invoices: invoices.map((inv) => ({
+        id: inv._id,
+        stripeInvoiceId: inv.stripeInvoiceId,
+        amount: inv.amount,
+        status: inv.status,
+        periodStart: inv.periodStart,
+        periodEnd: inv.periodEnd,
+        callCount: inv.callCount,
+        pdfUrl: inv.pdfUrl,
+        createdAt: inv.createdAt,
+      })),
+      // Check if payment method needed
+      needsPaymentMethod:
+        plan === "free" && workspace.usageCount >= workspace.usageLimit,
+    };
   },
 });
 
-// ============================================
-// USAGE REPORTING
-// ============================================
-
-// Report usage to Stripe (for metered billing)
-// Currently APIClaw Pro is flat-rate, but this prepares for metered billing
-export const reportUsage = action({
+/**
+ * Get current period usage
+ */
+export const getCurrentUsage = query({
   args: {
     workspaceId: v.id("workspaces"),
-    amount: v.number(),
-    description: v.optional(v.string()),
   },
-  handler: async (ctx, args): Promise<{ success: boolean; error?: string }> => {
-    // Get workspace
-    const workspace = await ctx.runQuery(api.billing.getWorkspace, { 
-      workspaceId: args.workspaceId 
-    });
-    
+  handler: async (ctx, args) => {
+    const workspace = await ctx.db.get(args.workspaceId);
     if (!workspace) {
-      return { success: false, error: "Workspace not found" };
+      throw new Error("Workspace not found");
     }
 
-    // Only track usage for paid tiers
-    if (workspace.tier === "free") {
-      // Free tier just uses incrementUsage in workspaces.ts
-      return { success: true };
-    }
+    // Current billing period (month)
+    const now = new Date();
+    const periodStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const periodEnd = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+    const periodStartStr = periodStart.toISOString().split("T")[0];
 
-    // For paid tiers, increment the usage counter
-    // Future: Report to Stripe Billing Meter when metered pricing is set up
-    await ctx.runMutation(api.billing.incrementWorkspaceUsage, {
-      workspaceId: args.workspaceId,
-      amount: args.amount,
-    });
+    // Get usage records for this period
+    const usageRecords = await ctx.db
+      .query("usageRecords")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId))
+      .collect();
 
-    // TODO: When metered pricing is configured, report to Stripe:
-    // await reportToStripeMeter(workspace.stripeCustomerId, args.amount);
+    const periodRecords = usageRecords.filter((r) => r.date >= periodStartStr);
+    const callCount = periodRecords.reduce((sum, r) => sum + r.callCount, 0);
 
-    return { success: true };
+    // Calculate estimated cost (for usage-based billing)
+    const FREE_CALLS = 100;
+    const COST_PER_CALL = 1; // 1 cent = $0.01
+    const billableCalls = Math.max(0, callCount - FREE_CALLS);
+    const estimatedCost = billableCalls * COST_PER_CALL;
+
+    return {
+      callCount,
+      periodStart: periodStart.getTime(),
+      periodEnd: periodEnd.getTime(),
+      limit: workspace.usageLimit,
+      remaining: Math.max(0, workspace.usageLimit - workspace.usageCount),
+      percentUsed: Math.round((workspace.usageCount / workspace.usageLimit) * 100),
+      billableCalls,
+      estimatedCostCents: estimatedCost,
+      dailyBreakdown: periodRecords.map((r) => ({
+        date: r.date,
+        calls: r.callCount,
+        reportedToStripe: r.reportedToStripe,
+      })),
+    };
   },
 });
 
-// Internal: Increment workspace usage
-export const incrementWorkspaceUsage = mutation({
+/**
+ * Get invoices for a workspace
+ */
+export const getInvoices = query({
   args: {
     workspaceId: v.id("workspaces"),
-    amount: v.number(),
+    limit: v.optional(v.number()),
   },
   handler: async (ctx, args) => {
-    const workspace = await ctx.db.get(args.workspaceId);
-    if (!workspace) return;
+    const limit = args.limit || 20;
+
+    const invoices = await ctx.db
+      .query("invoices")
+      .withIndex("by_workspaceId_createdAt", (q) =>
+        q.eq("workspaceId", args.workspaceId)
+      )
+      .order("desc")
+      .take(limit);
+
+    return invoices.map((inv) => ({
+      id: inv._id,
+      stripeInvoiceId: inv.stripeInvoiceId,
+      amount: inv.amount,
+      amountFormatted: `$${(inv.amount / 100).toFixed(2)}`,
+      status: inv.status,
+      periodStart: inv.periodStart,
+      periodEnd: inv.periodEnd,
+      callCount: inv.callCount,
+      pdfUrl: inv.pdfUrl,
+      createdAt: inv.createdAt,
+    }));
+  },
+});
 
-    await ctx.db.patch(args.workspaceId, {
-      usageCount: workspace.usageCount + args.amount,
-      updatedAt: Date.now(),
-    });
+/**
+ * Get unreported usage records (for cron job)
+ */
+export const getUnreportedUsage = query({
+  args: {},
+  handler: async (ctx) => {
+    const unreported = await ctx.db
+      .query("usageRecords")
+      .withIndex("by_reportedToStripe", (q) => q.eq("reportedToStripe", false))
+      .collect();
+
+    return unreported;
+  },
+});
+
+/**
+ * Get workspace by Stripe customer ID
+ */
+export const getByStripeCustomerId = query({
+  args: {
+    stripeCustomerId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("workspaces")
+      .withIndex("by_stripeCustomerId", (q) =>
+        q.eq("stripeCustomerId", args.stripeCustomerId)
+      )
+      .unique();
+  },
+});
+
+/**
+ * Get workspace by ID
+ */
+export const getWorkspace = query({
+  args: {
+    id: v.id("workspaces"),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
   },
 });
 
 // ============================================
-// QUERIES
+// STRIPE USAGE REPORTING (Internal Actions)
 // ============================================
 
-// Get billing status for workspace
-export const getBillingStatus = query({
+/**
+ * Get all workspaces with active Stripe subscriptions (internal)
+ */
+export const getActiveSubscriptions = internalQuery({
+  args: {},
+  handler: async (ctx) => {
+    // Get all workspaces with a subscription ID
+    const workspaces = await ctx.db
+      .query("workspaces")
+      .filter((q) => q.neq(q.field("stripeSubscriptionId"), undefined))
+      .collect();
+
+    // Filter to only those with billing plan that requires reporting
+    return workspaces.filter(
+      (w) => w.billingPlan === "usage_based" && w.stripeSubscriptionId
+    );
+  },
+});
+
+/**
+ * Get unreported usage records for a specific workspace (internal)
+ */
+export const getUnreportedUsageForWorkspace = internalQuery({
   args: {
     workspaceId: v.id("workspaces"),
   },
   handler: async (ctx, args) => {
-    const workspace = await ctx.db.get(args.workspaceId);
-    if (!workspace) {
-      return null;
+    return await ctx.db
+      .query("usageRecords")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", args.workspaceId))
+      .filter((q) => q.eq(q.field("reportedToStripe"), false))
+      .collect();
+  },
+});
+
+/**
+ * Mark multiple usage records as reported (internal)
+ */
+export const markUsageRecordsReported = internalMutation({
+  args: {
+    usageRecordIds: v.array(v.id("usageRecords")),
+    stripeUsageRecordId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    for (const recordId of args.usageRecordIds) {
+      await ctx.db.patch(recordId, {
+        reportedToStripe: true,
+        stripeUsageRecordId: args.stripeUsageRecordId,
+        updatedAt: now,
+      });
     }
+  },
+});
 
-    const usageRemaining = workspace.usageLimit > 0 
-      ? workspace.usageLimit - workspace.usageCount 
-      : -1;
+/**
+ * Report usage to Stripe for a single workspace
+ * Internal action - called by the daily cron
+ */
+export const reportUsageToStripe = internalAction({
+  args: {
+    workspaceId: v.id("workspaces"),
+    stripeSubscriptionId: v.string(),
+  },
+  handler: async (ctx, args): Promise<{ success: boolean; callCount: number; error?: string }> => {
+    try {
+      // Get unreported usage records
+      const usageRecords = await ctx.runQuery(
+        internal.billing.getUnreportedUsageForWorkspace,
+        { workspaceId: args.workspaceId }
+      );
+
+      if (usageRecords.length === 0) {
+        return { success: true, callCount: 0 };
+      }
 
-    const usagePercent = workspace.usageLimit > 0
-      ? Math.round((workspace.usageCount / workspace.usageLimit) * 100)
-      : 0;
+      // Sum up all unreported calls
+      const totalCalls = usageRecords.reduce(
+        (sum: number, r: { callCount: number }) => sum + r.callCount,
+        0
+      );
+
+      if (totalCalls === 0) {
+        // Mark as reported even if 0 calls (to prevent re-processing)
+        await ctx.runMutation(internal.billing.markUsageRecordsReported, {
+          usageRecordIds: usageRecords.map((r: { _id: Id<"usageRecords"> }) => r._id),
+          stripeUsageRecordId: "zero_usage",
+        });
+        return { success: true, callCount: 0 };
+      }
 
-    return {
-      tier: workspace.tier,
-      status: workspace.status,
-      usageCount: workspace.usageCount,
-      usageLimit: workspace.usageLimit,
-      usageRemaining,
-      usagePercent,
-      hasStripe: !!workspace.stripeCustomerId,
-      email: workspace.email,
+      const stripe = getStripe();
+
+      // Get subscription to find the metered subscription item
+      const subscription = await stripe.subscriptions.retrieve(args.stripeSubscriptionId);
+
+      // Find the metered price item (usage_based price)
+      const meteredItem = subscription.items.data.find((item) => {
+        return item.price.recurring?.usage_type === "metered";
+      });
+
+      if (!meteredItem) {
+        console.error(
+          `No metered subscription item found for subscription ${args.stripeSubscriptionId}`
+        );
+        return {
+          success: false,
+          callCount: totalCalls,
+          error: "No metered subscription item found",
+        };
+      }
+
+      // Report usage to Stripe using usage records API
+      // Using raw fetch since SDK method varies by version
+      const stripeKey = process.env.STRIPE_SECRET_KEY;
+      const usageRecordResponse = await fetch(
+        `https://api.stripe.com/v1/subscription_items/${meteredItem.id}/usage_records`,
+        {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${stripeKey}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+          body: new URLSearchParams({
+            quantity: String(totalCalls),
+            timestamp: String(Math.floor(Date.now() / 1000)),
+            action: "increment",
+          }),
+        }
+      );
+
+      if (!usageRecordResponse.ok) {
+        const errorData = await usageRecordResponse.text();
+        throw new Error(`Stripe API error: ${usageRecordResponse.status} - ${errorData}`);
+      }
+
+      const usageRecord = await usageRecordResponse.json() as { id: string };
+
+      // Mark records as reported
+      await ctx.runMutation(internal.billing.markUsageRecordsReported, {
+        usageRecordIds: usageRecords.map((r: { _id: Id<"usageRecords"> }) => r._id),
+        stripeUsageRecordId: usageRecord.id,
+      });
+
+      console.log(
+        `Reported ${totalCalls} calls for workspace ${args.workspaceId} to Stripe`
+      );
+
+      return { success: true, callCount: totalCalls };
+    } catch (error: any) {
+      console.error(
+        `Failed to report usage for workspace ${args.workspaceId}:`,
+        error
+      );
+      return {
+        success: false,
+        callCount: 0,
+        error: error.message || "Unknown error",
+      };
+    }
+  },
+});
+
+// Type for workspace with active subscription
+type ActiveWorkspace = {
+  _id: Id<"workspaces">;
+  email: string;
+  stripeSubscriptionId?: string;
+};
+
+// Type for cron results
+type CronResults = {
+  total: number;
+  success: number;
+  failed: number;
+  skipped: number;
+  totalCallsReported: number;
+  errors: string[];
+};
+
+/**
+ * Daily cron job: Report all unreported usage to Stripe
+ * Runs at 00:05 UTC
+ */
+export const reportAllUsageToStripe = internalAction({
+  args: {},
+  handler: async (ctx): Promise<CronResults> => {
+    console.log("[Cron] Starting daily usage reporting to Stripe...");
+
+    // Get all workspaces with active subscriptions
+    const workspaces: ActiveWorkspace[] = await ctx.runQuery(
+      internal.billing.getActiveSubscriptions,
+      {}
+    );
+
+    console.log(`[Cron] Found ${workspaces.length} workspaces with active subscriptions`);
+
+    const results: CronResults = {
+      total: workspaces.length,
+      success: 0,
+      failed: 0,
+      skipped: 0,
+      totalCallsReported: 0,
+      errors: [],
     };
+
+    // Process each workspace
+    for (const workspace of workspaces) {
+      if (!workspace.stripeSubscriptionId) {
+        results.skipped++;
+        continue;
+      }
+
+      try {
+        const result = await ctx.runAction(internal.billing.reportUsageToStripe, {
+          workspaceId: workspace._id,
+          stripeSubscriptionId: workspace.stripeSubscriptionId,
+        });
+
+        if (result.success) {
+          results.success++;
+          results.totalCallsReported += result.callCount;
+        } else {
+          results.failed++;
+          results.errors.push(
+            `${workspace.email}: ${result.error || "Unknown error"}`
+          );
+        }
+      } catch (error: any) {
+        results.failed++;
+        results.errors.push(`${workspace.email}: ${error.message || "Unknown error"}`);
+        console.error(`[Cron] Error processing workspace ${workspace._id}:`, error);
+        // Continue with next workspace
+      }
+    }
+
+    console.log("[Cron] Daily usage reporting complete:", JSON.stringify(results));
+
+    return results;
   },
 });