Enhance usage and spending tracking logic

Adds support for fetching and displaying aggregate usage summary and hard limit data from new API endpoints. Improves logic for resolving hard limit values, updates models to include new fields, and refines status bar display to show both requests and spending information. This provides more accurate and comprehensive usage reporting for both individual and team flows.

Author: genseric

src/api.ts

@@ -1,5 +1,13 @@
 import * as https from "https";
-import { TeamsResponse, TeamDetails, SpendData, UserMeResponse, UserUsageResponse } from "./models";
+import {
+  TeamsResponse,
+  TeamDetails,
+  SpendData,
+  UserMeResponse,
+  UserUsageResponse,
+  UsageSummaryResponse,
+  HardLimitResponse,
+} from "./models";
 
 const BASE_URL = "https://cursor.com/api";
 
@@ -120,3 +128,13 @@ export async function fetchUserMe(cookie: string): Promise<UserMeResponse> {
 export async function fetchUserUsage(userId: string, cookie: string): Promise<UserUsageResponse> {
   return get<UserUsageResponse>(`usage?user=${userId}`, cookie);
 }
+
+/** Fetches the aggregate usage summary, including on-demand USD usage. */
+export async function fetchUsageSummary(cookie: string): Promise<UsageSummaryResponse> {
+  return get<UsageSummaryResponse>("usage-summary", cookie);
+}
+
+/** Fetches the current hard limit for on-demand spending. */
+export async function fetchHardLimit(cookie: string): Promise<HardLimitResponse> {
+  return get<HardLimitResponse>("dashboard/get-hard-limit", cookie);
+}

src/extension.ts

@@ -2,9 +2,10 @@ import * as vscode from "vscode";
 import * as api from "./api";
 import * as statusBar from "./statusBar";
 import * as config from "./configuration";
-import { TeamMemberSpend } from "./models";
+import { SpendData, TeamMemberSpend } from "./models";
 
 let refreshTimer: NodeJS.Timeout | undefined;
+const CENTS_PER_DOLLAR = 100;
 
 /**
  * Calculates the next reset date based on the start of month date.
@@ -33,6 +34,63 @@ function calculateResetInfo(startOfMonth: string): {
   return { resetDate, daysRemaining, resetDateStr };
 }
 
+function resolveHardLimitDollars(
+  spendData?: SpendData,
+  memberSpend?: TeamMemberSpend
+): number | undefined {
+  const memberCandidates = [
+    memberSpend?.hardLimitOverrideDollars,
+    memberSpend?.hardLimitDollars,
+  ];
+
+  for (const candidate of memberCandidates) {
+    if (isValidNumber(candidate)) {
+      return candidate;
+    }
+  }
+
+  if (!spendData) {
+    return undefined;
+  }
+
+  const teamDollarCandidates = [
+    spendData.teamHardLimitDollars,
+    spendData.hardLimitDollars,
+    spendData.defaultHardLimitDollars,
+  ];
+
+  for (const candidate of teamDollarCandidates) {
+    if (isValidNumber(candidate)) {
+      return candidate;
+    }
+  }
+
+  const teamCentCandidates = [
+    spendData.teamHardLimitCents,
+    spendData.hardLimitCents,
+    spendData.defaultHardLimitCents,
+  ];
+
+  for (const candidate of teamCentCandidates) {
+    if (isValidNumber(candidate)) {
+      return candidate / 100;
+    }
+  }
+
+  return undefined;
+}
+
+function isValidNumber(value?: number | null): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function dollarsToCents(amount?: number | null): number | undefined {
+  if (!isValidNumber(amount)) {
+    return undefined;
+  }
+  return Math.round(amount );
+}
+
 /**
  * This is the main activation function for the extension.
  * It's called by VS Code when the extension is activated.
@@ -191,12 +249,14 @@ async function refreshUsage(context: vscode.ExtensionContext): Promise<void> {
 
     // TEAM FLOW: Try to get team-based usage data if user has related team from api/sets a team ID manually
     // If we couldn't get team spend data, we'll show a simplified view with just the individual user data
-    if (teamId) {
+  let teamSpendData: SpendData | undefined;
+
+  if (teamId) {
       try {
         const userDetails = await api.fetchTeamDetails(teamId, cookie);
-        const spendData = await api.fetchTeamSpend(teamId, cookie);
+      teamSpendData = await api.fetchTeamSpend(teamId, cookie);
 
-        mySpend = spendData.teamMemberSpend.find(
+      mySpend = teamSpendData.teamMemberSpend.find(
           (member) => member.userId === userDetails.userId
         );
       } catch (teamError: any) {
@@ -221,7 +281,47 @@ async function refreshUsage(context: vscode.ExtensionContext): Promise<void> {
       // TEAM FLOW: Use team-based data when available
       usedRequests = mySpend.fastPremiumRequests;
       spendCents = mySpend.spendCents;
-      hardLimitDollars = mySpend.hardLimitOverrideDollars;
+      hardLimitDollars = resolveHardLimitDollars(teamSpendData, mySpend);
+    }
+
+    if (spendCents === undefined || hardLimitDollars === undefined) {
+      try {
+        const usageSummary = await api.fetchUsageSummary(cookie);
+        const onDemandUsage = usageSummary.individualUsage?.onDemand;
+
+        if (onDemandUsage?.enabled) {
+          if (spendCents === undefined) {
+            const usageCents = dollarsToCents(onDemandUsage.used);
+            if (usageCents !== undefined) {
+              spendCents = usageCents;
+            }
+          }
+
+          if (hardLimitDollars === undefined && isValidNumber(onDemandUsage.limit)) {
+            hardLimitDollars = dollarsToCents(onDemandUsage.limit);
+            if (hardLimitDollars !== undefined) {
+              hardLimitDollars = hardLimitDollars / 100;
+            }
+          }
+        }
+      } catch (summaryError: any) {
+        console.warn(
+          `[Cursor Usage] Failed to fetch usage summary: ${summaryError.message}`
+        );
+      }
+    }
+
+    if (hardLimitDollars === undefined) {
+      try {
+        const hardLimitResponse = await api.fetchHardLimit(cookie);
+        if (isValidNumber(hardLimitResponse.hardLimit)) {
+          hardLimitDollars = hardLimitResponse.hardLimit;
+        }
+      } catch (hardLimitError: any) {
+        console.warn(
+          `[Cursor Usage] Failed to fetch hard limit: ${hardLimitError.message}`
+        );
+      }
     }
 
     // Calculate final values and update status bar
@@ -231,6 +331,7 @@ async function refreshUsage(context: vscode.ExtensionContext): Promise<void> {
     statusBar.updateStatusBar(
       remainingRequests,
       maxRequests,
+      usedRequests,
       spendCents,
       hardLimitDollars,
       resetInfo

src/models.ts

@@ -30,6 +30,7 @@ export interface TeamMemberSpend {
   userId?: number;
   spendCents?: number;
   hardLimitOverrideDollars?: number;
+  hardLimitDollars?: number;
   name?: string;
   role?: string;
 }
@@ -40,6 +41,43 @@ export interface TeamMemberSpend {
  */
 export interface SpendData {
   teamMemberSpend: TeamMemberSpend[];
+  hardLimitDollars?: number;
+  hardLimitCents?: number;
+  defaultHardLimitDollars?: number;
+  defaultHardLimitCents?: number;
+  teamHardLimitDollars?: number;
+  teamHardLimitCents?: number;
+}
+
+interface UsageSummaryBreakdown {
+  included?: number;
+  bonus?: number;
+  total?: number;
+}
+
+export interface UsageSummaryMetric {
+  enabled: boolean;
+  used: number;
+  limit: number;
+  remaining: number;
+  breakdown?: UsageSummaryBreakdown;
+}
+
+export interface UsageSummaryResponse {
+  billingCycleStart: string;
+  billingCycleEnd: string;
+  membershipType?: string;
+  limitType?: string;
+  isUnlimited?: boolean;
+  individualUsage?: {
+    plan?: UsageSummaryMetric;
+    onDemand?: UsageSummaryMetric;
+  };
+  teamUsage?: Record<string, unknown>;
+}
+
+export interface HardLimitResponse {
+  hardLimit: number;
 }
 
 /**

src/statusBar.ts

@@ -29,13 +29,15 @@ export function createStatusBarItem() {
  * Updates the status bar with the remaining requests, spending info, reset info, and appropriate color/icon.
  * @param remainingRequests The number of requests left.
  * @param totalRequests The total number of requests allowed in the cycle.
+ * @param usedRequests The number of requests already used in the cycle.
  * @param spendCents The amount spent in cents (optional).
  * @param hardLimitDollars The hard limit in dollars (optional).
  * @param resetInfo Information about when the usage resets (optional).
  */
 export function updateStatusBar(
   remainingRequests: number,
   totalRequests: number,
+  usedRequests: number,
   spendCents?: number,
   hardLimitDollars?: number,
   resetInfo?: ResetInfo
@@ -92,15 +94,22 @@ export function updateStatusBar(
   // Only show spending when there are 0 requests left
   let statusText: string;
 
+  const normalizedUsedRequests = Math.max(0, usedRequests);
+  const usageSummary = `${normalizedUsedRequests}/${totalRequests}`;
+  const spendSummary =
+    spendCents !== undefined && hardLimitDollars !== undefined
+      ? `$${(spendCents / 100).toFixed(2)}/$${hardLimitDollars.toFixed(2)}`
+      : undefined;
+
   if (remainingRequests > 0) {
     // Show remaining requests
-    statusText = `${icon} ${remainingRequests}`;
+    statusText = spendSummary
+      ? `${icon} ${remainingRequests} · ${spendSummary}`
+      : `${icon} ${remainingRequests} · ${usageSummary}`;
   } else {
     // No requests left - show spending instead (if available)
-    if (spendCents !== undefined && hardLimitDollars !== undefined) {
-      const spendDollars = (spendCents / 100).toFixed(2);
-      const limitDollars = hardLimitDollars.toFixed(2);
-      statusText = `${icon} $${spendDollars}/$${limitDollars}`;
+    if (spendSummary) {
+      statusText = `${icon} ${spendSummary}`;
     } else {
       // No spending data available, just show 0
       statusText = `${icon} 0`;
@@ -112,6 +121,7 @@ export function updateStatusBar(
   // Update tooltip with detailed information
   updateTooltip(
     remainingRequests,
+    normalizedUsedRequests,
     totalRequests,
     spendCents,
     hardLimitDollars,
@@ -122,13 +132,15 @@ export function updateStatusBar(
 /**
  * Updates the tooltip with comprehensive usage, spending, and reset information.
  * @param remainingRequests The number of requests left.
+ * @param usedRequests The number of requests already used in the cycle.
  * @param totalRequests The total number of requests allowed in the cycle.
  * @param spendCents The amount spent in cents (optional).
  * @param hardLimitDollars The hard limit in dollars (optional).
  * @param resetInfo Information about when the usage resets (optional).
  */
 function updateTooltip(
   remainingRequests: number,
+  usedRequests: number,
   totalRequests: number,
   spendCents?: number,
   hardLimitDollars?: number,
@@ -138,8 +150,10 @@ function updateTooltip(
     return;
   }
 
-  const usedRequests = totalRequests - remainingRequests;
-  const requestPercentage = ((usedRequests / totalRequests) * 100).toFixed(1);
+  const usageForDisplay = Math.max(0, usedRequests);
+  const requestPercentage = totalRequests
+    ? ((usageForDisplay / totalRequests) * 100).toFixed(1)
+    : "0.0";
 
   // Calculate cycle information once if resetInfo is available
   let daysElapsed = 0;