@commet/better-auth 1.3.2 → 1.3.4

package/dist/index.cjs

@@ -308,185 +308,33 @@ var commetClient = () => {
   };
 };
 
-// src/plugins/portal.ts
-var import_api2 = require("better-auth/api");
-var import_plugins = require("better-auth/plugins");
-var portal = ({ returnUrl } = {}) => (commet2) => {
-  return {
-    portal: (0, import_plugins.createAuthEndpoint)(
-      "/commet/portal",
-      {
-        method: "GET",
-        use: [import_api2.sessionMiddleware]
-      },
-      async (ctx) => {
-        const userId = ctx.context.session?.user.id;
-        if (!userId) {
-          throw new import_api2.APIError("UNAUTHORIZED", {
-            message: "You must be logged in to access the customer portal"
-          });
-        }
-        try {
-          const portalAccess = await commet2.portal.getUrl({
-            externalId: userId
-          });
-          if (!portalAccess.success || !portalAccess.data) {
-            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
-              message: portalAccess.message || "Failed to generate portal URL"
-            });
-          }
-          let portalUrl = portalAccess.data.portalUrl;
-          if (returnUrl) {
-            const url = new URL(portalUrl);
-            url.searchParams.set("return_url", returnUrl);
-            portalUrl = url.toString();
-          }
-          return ctx.json({
-            url: portalUrl,
-            redirect: true
-          });
-        } catch (e) {
-          if (e instanceof import_api2.APIError) {
-            throw e;
-          }
-          if (e instanceof Error) {
-            ctx.context.logger.error(
-              `Commet portal access failed: ${e.message}`
-            );
-          }
-          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
-            message: "Failed to access customer portal"
-          });
-        }
-      }
-    )
-  };
-};
-
-// src/plugins/subscriptions.ts
-var import_api3 = require("better-auth/api");
-var import_plugins2 = require("better-auth/plugins");
-var import_zod = require("zod");
-var CancelSchema = import_zod.z.object({
-  reason: import_zod.z.string().optional(),
-  immediate: import_zod.z.boolean().optional()
-});
-var subscriptions = (config = {}) => (commet2) => {
-  return {
-    getSubscription: (0, import_plugins2.createAuthEndpoint)(
-      "/commet/subscription",
-      {
-        method: "GET",
-        use: [import_api3.sessionMiddleware]
-      },
-      async (ctx) => {
-        const userId = ctx.context.session?.user.id;
-        if (!userId) {
-          throw new import_api3.APIError("UNAUTHORIZED", {
-            message: "You must be logged in to view subscription"
-          });
-        }
-        try {
-          const subscription = await commet2.subscriptions.get(userId);
-          if (!subscription.success) {
-            throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
-              message: subscription.message || "Failed to retrieve subscription"
-            });
-          }
-          return ctx.json(subscription.data ?? null);
-        } catch (e) {
-          if (e instanceof import_api3.APIError) {
-            throw e;
-          }
-          if (e instanceof Error) {
-            ctx.context.logger.error(
-              `Commet subscription get failed: ${e.message}`
-            );
-          }
-          throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
-            message: "Failed to retrieve subscription"
-          });
-        }
-      }
-    ),
-    cancelSubscription: (0, import_plugins2.createAuthEndpoint)(
-      "/commet/subscription/cancel",
-      {
-        method: "POST",
-        body: CancelSchema.optional(),
-        use: [import_api3.sessionMiddleware]
-      },
-      async (ctx) => {
-        const userId = ctx.context.session?.user.id;
-        if (!userId) {
-          throw new import_api3.APIError("UNAUTHORIZED", {
-            message: "You must be logged in to cancel subscription"
-          });
-        }
-        try {
-          const currentSub = await commet2.subscriptions.get(userId);
-          if (!currentSub.success || !currentSub.data) {
-            throw new import_api3.APIError("BAD_REQUEST", {
-              message: "No active subscription found"
-            });
-          }
-          const result = await commet2.subscriptions.cancel({
-            subscriptionId: currentSub.data.id,
-            reason: ctx.body?.reason,
-            immediate: ctx.body?.immediate
-          });
-          if (!result.success) {
-            throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
-              message: result.message || "Failed to cancel subscription"
-            });
-          }
-          return ctx.json(result.data ?? null);
-        } catch (e) {
-          if (e instanceof import_api3.APIError) {
-            throw e;
-          }
-          if (e instanceof Error) {
-            ctx.context.logger.error(
-              `Commet subscription cancel failed: ${e.message}`
-            );
-          }
-          throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
-            message: "Failed to cancel subscription"
-          });
-        }
-      }
-    )
-  };
-};
-
 // src/plugins/features.ts
-var import_api4 = require("better-auth/api");
-var import_plugins3 = require("better-auth/plugins");
+var import_api2 = require("better-auth/api");
 var features = (_config = {}) => (commet2) => {
   return {
-    listFeatures: (0, import_plugins3.createAuthEndpoint)(
+    listFeatures: (0, import_api2.createAuthEndpoint)(
       "/commet/features",
       {
         method: "GET",
-        use: [import_api4.sessionMiddleware]
+        use: [import_api2.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api4.APIError("UNAUTHORIZED", {
+          throw new import_api2.APIError("UNAUTHORIZED", {
             message: "You must be logged in to view features"
           });
         }
         try {
           const result = await commet2.features.list(userId);
           if (!result.success) {
-            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to list features"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api4.APIError) {
+          if (e instanceof import_api2.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -494,28 +342,28 @@ var features = (_config = {}) => (commet2) => {
               `Commet features list failed: ${e.message}`
             );
           }
-          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to list features"
           });
         }
       }
     ),
-    getFeature: (0, import_plugins3.createAuthEndpoint)(
+    getFeature: (0, import_api2.createAuthEndpoint)(
       "/commet/features/:code",
       {
         method: "GET",
-        use: [import_api4.sessionMiddleware]
+        use: [import_api2.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         const code = ctx.params?.code;
         if (!userId) {
-          throw new import_api4.APIError("UNAUTHORIZED", {
+          throw new import_api2.APIError("UNAUTHORIZED", {
             message: "You must be logged in to view feature"
           });
         }
         if (!code) {
-          throw new import_api4.APIError("BAD_REQUEST", {
+          throw new import_api2.APIError("BAD_REQUEST", {
             message: "Feature code is required"
           });
         }
@@ -525,13 +373,13 @@ var features = (_config = {}) => (commet2) => {
             code
           });
           if (!result.success) {
-            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to get feature"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api4.APIError) {
+          if (e instanceof import_api2.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -539,28 +387,28 @@ var features = (_config = {}) => (commet2) => {
               `Commet feature get failed: ${e.message}`
             );
           }
-          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to get feature"
           });
         }
       }
     ),
-    checkFeature: (0, import_plugins3.createAuthEndpoint)(
+    checkFeature: (0, import_api2.createAuthEndpoint)(
       "/commet/features/:code/check",
       {
         method: "GET",
-        use: [import_api4.sessionMiddleware]
+        use: [import_api2.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         const code = ctx.params?.code;
         if (!userId) {
-          throw new import_api4.APIError("UNAUTHORIZED", {
+          throw new import_api2.APIError("UNAUTHORIZED", {
             message: "You must be logged in to check feature"
           });
         }
         if (!code) {
-          throw new import_api4.APIError("BAD_REQUEST", {
+          throw new import_api2.APIError("BAD_REQUEST", {
             message: "Feature code is required"
           });
         }
@@ -570,13 +418,13 @@ var features = (_config = {}) => (commet2) => {
             code
           });
           if (!result.success) {
-            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to check feature"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api4.APIError) {
+          if (e instanceof import_api2.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -584,28 +432,28 @@ var features = (_config = {}) => (commet2) => {
               `Commet feature check failed: ${e.message}`
             );
           }
-          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to check feature"
           });
         }
       }
     ),
-    canUseFeature: (0, import_plugins3.createAuthEndpoint)(
+    canUseFeature: (0, import_api2.createAuthEndpoint)(
       "/commet/features/:code/can-use",
       {
         method: "GET",
-        use: [import_api4.sessionMiddleware]
+        use: [import_api2.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         const code = ctx.params?.code;
         if (!userId) {
-          throw new import_api4.APIError("UNAUTHORIZED", {
+          throw new import_api2.APIError("UNAUTHORIZED", {
             message: "You must be logged in to check feature usage"
           });
         }
         if (!code) {
-          throw new import_api4.APIError("BAD_REQUEST", {
+          throw new import_api2.APIError("BAD_REQUEST", {
             message: "Feature code is required"
           });
         }
@@ -615,13 +463,13 @@ var features = (_config = {}) => (commet2) => {
             code
           });
           if (!result.success) {
-            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to check feature usage"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api4.APIError) {
+          if (e instanceof import_api2.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -629,7 +477,7 @@ var features = (_config = {}) => (commet2) => {
               `Commet feature canUse failed: ${e.message}`
             );
           }
-          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api2.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to check feature usage"
           });
         }
@@ -638,60 +486,53 @@ var features = (_config = {}) => (commet2) => {
   };
 };
 
-// src/plugins/usage.ts
-var import_api5 = require("better-auth/api");
-var import_plugins4 = require("better-auth/plugins");
-var import_zod2 = require("zod");
-var TrackEventSchema = import_zod2.z.object({
-  feature: import_zod2.z.string(),
-  value: import_zod2.z.number().optional(),
-  idempotencyKey: import_zod2.z.string().optional(),
-  properties: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
-});
-var usage = (_config = {}) => (commet2) => {
+// src/plugins/portal.ts
+var import_api3 = require("better-auth/api");
+var portal = ({ returnUrl } = {}) => (commet2) => {
   return {
-    trackUsage: (0, import_plugins4.createAuthEndpoint)(
-      "/commet/usage/track",
+    portal: (0, import_api3.createAuthEndpoint)(
+      "/commet/portal",
       {
-        method: "POST",
-        body: TrackEventSchema,
-        use: [import_api5.sessionMiddleware]
+        method: "GET",
+        use: [import_api3.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api5.APIError("UNAUTHORIZED", {
-            message: "You must be logged in to track usage"
+          throw new import_api3.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to access the customer portal"
           });
         }
         try {
-          const result = await commet2.usage.track(
-            {
-              externalId: userId,
-              feature: ctx.body.feature,
-              value: ctx.body.value,
-              idempotencyKey: ctx.body.idempotencyKey,
-              properties: ctx.body.properties
-            },
-            {}
-          );
-          if (!result.success) {
-            throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
-              message: result.message || "Failed to track usage"
+          const portalAccess = await commet2.portal.getUrl({
+            externalId: userId
+          });
+          if (!portalAccess.success || !portalAccess.data) {
+            throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+              message: portalAccess.message || "Failed to generate portal URL"
             });
           }
-          return ctx.json(result.data ?? null);
+          let portalUrl = portalAccess.data.portalUrl;
+          if (returnUrl) {
+            const url = new URL(portalUrl);
+            url.searchParams.set("return_url", returnUrl);
+            portalUrl = url.toString();
+          }
+          return ctx.json({
+            url: portalUrl,
+            redirect: true
+          });
         } catch (e) {
-          if (e instanceof import_api5.APIError) {
+          if (e instanceof import_api3.APIError) {
             throw e;
           }
           if (e instanceof Error) {
             ctx.context.logger.error(
-              `Commet usage track failed: ${e.message}`
+              `Commet portal access failed: ${e.message}`
             );
           }
-          throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
-            message: "Failed to track usage"
+          throw new import_api3.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to access customer portal"
           });
         }
       }
@@ -700,28 +541,27 @@ var usage = (_config = {}) => (commet2) => {
 };
 
 // src/plugins/seats.ts
-var import_api6 = require("better-auth/api");
-var import_plugins5 = require("better-auth/plugins");
-var import_zod3 = require("zod");
-var SeatOperationSchema = import_zod3.z.object({
-  seatType: import_zod3.z.string(),
-  count: import_zod3.z.number().min(1)
+var import_api4 = require("better-auth/api");
+var import_zod = require("zod");
+var SeatOperationSchema = import_zod.z.object({
+  seatType: import_zod.z.string(),
+  count: import_zod.z.number().min(1)
 });
-var SetAllSeatsSchema = import_zod3.z.object({
-  seats: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())
+var SetAllSeatsSchema = import_zod.z.object({
+  seats: import_zod.z.record(import_zod.z.string(), import_zod.z.number())
 });
 var seats = (_config = {}) => (commet2) => {
   return {
-    listSeats: (0, import_plugins5.createAuthEndpoint)(
+    listSeats: (0, import_api4.createAuthEndpoint)(
       "/commet/seats",
       {
         method: "GET",
-        use: [import_api6.sessionMiddleware]
+        use: [import_api4.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api6.APIError("UNAUTHORIZED", {
+          throw new import_api4.APIError("UNAUTHORIZED", {
             message: "You must be logged in to view seats"
           });
         }
@@ -730,13 +570,13 @@ var seats = (_config = {}) => (commet2) => {
             externalId: userId
           });
           if (!result.success) {
-            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to list seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api6.APIError) {
+          if (e instanceof import_api4.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -744,23 +584,23 @@ var seats = (_config = {}) => (commet2) => {
               `Commet seats list failed: ${e.message}`
             );
           }
-          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to list seats"
           });
         }
       }
     ),
-    addSeats: (0, import_plugins5.createAuthEndpoint)(
+    addSeats: (0, import_api4.createAuthEndpoint)(
       "/commet/seats/add",
       {
         method: "POST",
         body: SeatOperationSchema,
-        use: [import_api6.sessionMiddleware]
+        use: [import_api4.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api6.APIError("UNAUTHORIZED", {
+          throw new import_api4.APIError("UNAUTHORIZED", {
             message: "You must be logged in to add seats"
           });
         }
@@ -774,35 +614,35 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to add seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api6.APIError) {
+          if (e instanceof import_api4.APIError) {
             throw e;
           }
           if (e instanceof Error) {
             ctx.context.logger.error(`Commet seats add failed: ${e.message}`);
           }
-          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to add seats"
           });
         }
       }
     ),
-    removeSeats: (0, import_plugins5.createAuthEndpoint)(
+    removeSeats: (0, import_api4.createAuthEndpoint)(
       "/commet/seats/remove",
       {
         method: "POST",
         body: SeatOperationSchema,
-        use: [import_api6.sessionMiddleware]
+        use: [import_api4.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api6.APIError("UNAUTHORIZED", {
+          throw new import_api4.APIError("UNAUTHORIZED", {
             message: "You must be logged in to remove seats"
           });
         }
@@ -816,13 +656,13 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to remove seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api6.APIError) {
+          if (e instanceof import_api4.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -830,23 +670,23 @@ var seats = (_config = {}) => (commet2) => {
               `Commet seats remove failed: ${e.message}`
             );
           }
-          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to remove seats"
           });
         }
       }
     ),
-    setSeats: (0, import_plugins5.createAuthEndpoint)(
+    setSeats: (0, import_api4.createAuthEndpoint)(
       "/commet/seats/set",
       {
         method: "POST",
         body: SeatOperationSchema,
-        use: [import_api6.sessionMiddleware]
+        use: [import_api4.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api6.APIError("UNAUTHORIZED", {
+          throw new import_api4.APIError("UNAUTHORIZED", {
             message: "You must be logged in to set seats"
           });
         }
@@ -860,35 +700,35 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to set seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api6.APIError) {
+          if (e instanceof import_api4.APIError) {
             throw e;
           }
           if (e instanceof Error) {
             ctx.context.logger.error(`Commet seats set failed: ${e.message}`);
           }
-          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to set seats"
           });
         }
       }
     ),
-    setAllSeats: (0, import_plugins5.createAuthEndpoint)(
+    setAllSeats: (0, import_api4.createAuthEndpoint)(
       "/commet/seats/set-all",
       {
         method: "POST",
         body: SetAllSeatsSchema,
-        use: [import_api6.sessionMiddleware]
+        use: [import_api4.sessionMiddleware]
       },
       async (ctx) => {
         const userId = ctx.context.session?.user.id;
         if (!userId) {
-          throw new import_api6.APIError("UNAUTHORIZED", {
+          throw new import_api4.APIError("UNAUTHORIZED", {
             message: "You must be logged in to set seats"
           });
         }
@@ -901,13 +741,13 @@ var seats = (_config = {}) => (commet2) => {
             {}
           );
           if (!result.success) {
-            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
               message: result.message || "Failed to set all seats"
             });
           }
           return ctx.json(result.data ?? null);
         } catch (e) {
-          if (e instanceof import_api6.APIError) {
+          if (e instanceof import_api4.APIError) {
             throw e;
           }
           if (e instanceof Error) {
@@ -915,7 +755,7 @@ var seats = (_config = {}) => (commet2) => {
               `Commet seats set-all failed: ${e.message}`
             );
           }
-          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+          throw new import_api4.APIError("INTERNAL_SERVER_ERROR", {
             message: "Failed to set all seats"
           });
         }
@@ -924,6 +764,161 @@ var seats = (_config = {}) => (commet2) => {
   };
 };
 
+// src/plugins/subscriptions.ts
+var import_api5 = require("better-auth/api");
+var import_zod2 = require("zod");
+var CancelSchema = import_zod2.z.object({
+  reason: import_zod2.z.string().optional(),
+  immediate: import_zod2.z.boolean().optional()
+});
+var subscriptions = (_config = {}) => (commet2) => {
+  return {
+    getSubscription: (0, import_api5.createAuthEndpoint)(
+      "/commet/subscription",
+      {
+        method: "GET",
+        use: [import_api5.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api5.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to view subscription"
+          });
+        }
+        try {
+          const subscription = await commet2.subscriptions.get(userId);
+          if (!subscription.success) {
+            throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+              message: subscription.message || "Failed to retrieve subscription"
+            });
+          }
+          return ctx.json(subscription.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api5.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription get failed: ${e.message}`
+            );
+          }
+          throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to retrieve subscription"
+          });
+        }
+      }
+    ),
+    cancelSubscription: (0, import_api5.createAuthEndpoint)(
+      "/commet/subscription/cancel",
+      {
+        method: "POST",
+        body: CancelSchema.optional(),
+        use: [import_api5.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api5.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to cancel subscription"
+          });
+        }
+        try {
+          const currentSub = await commet2.subscriptions.get(userId);
+          if (!currentSub.success || !currentSub.data) {
+            throw new import_api5.APIError("BAD_REQUEST", {
+              message: "No active subscription found"
+            });
+          }
+          const result = await commet2.subscriptions.cancel({
+            subscriptionId: currentSub.data.id,
+            reason: ctx.body?.reason,
+            immediate: ctx.body?.immediate
+          });
+          if (!result.success) {
+            throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to cancel subscription"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api5.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet subscription cancel failed: ${e.message}`
+            );
+          }
+          throw new import_api5.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to cancel subscription"
+          });
+        }
+      }
+    )
+  };
+};
+
+// src/plugins/usage.ts
+var import_api6 = require("better-auth/api");
+var import_zod3 = require("zod");
+var TrackEventSchema = import_zod3.z.object({
+  feature: import_zod3.z.string(),
+  value: import_zod3.z.number().optional(),
+  idempotencyKey: import_zod3.z.string().optional(),
+  properties: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
+});
+var usage = (_config = {}) => (commet2) => {
+  return {
+    trackUsage: (0, import_api6.createAuthEndpoint)(
+      "/commet/usage/track",
+      {
+        method: "POST",
+        body: TrackEventSchema,
+        use: [import_api6.sessionMiddleware]
+      },
+      async (ctx) => {
+        const userId = ctx.context.session?.user.id;
+        if (!userId) {
+          throw new import_api6.APIError("UNAUTHORIZED", {
+            message: "You must be logged in to track usage"
+          });
+        }
+        try {
+          const result = await commet2.usage.track(
+            {
+              externalId: userId,
+              feature: ctx.body.feature,
+              value: ctx.body.value,
+              idempotencyKey: ctx.body.idempotencyKey,
+              properties: ctx.body.properties
+            },
+            {}
+          );
+          if (!result.success) {
+            throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+              message: result.message || "Failed to track usage"
+            });
+          }
+          return ctx.json(result.data ?? null);
+        } catch (e) {
+          if (e instanceof import_api6.APIError) {
+            throw e;
+          }
+          if (e instanceof Error) {
+            ctx.context.logger.error(
+              `Commet usage track failed: ${e.message}`
+            );
+          }
+          throw new import_api6.APIError("INTERNAL_SERVER_ERROR", {
+            message: "Failed to track usage"
+          });
+        }
+      }
+    )
+  };
+};
+
 // src/plugins/webhooks.ts
 var import_api7 = require("better-auth/api");
 var EVENT_HANDLER_MAP = {