@magpie-community/opencode-cursor-auth 0.2.29 → 0.2.31

package/README.md

@@ -254,6 +254,32 @@ own spends the team's pool: On-demand shows the pool's spend and limit,
 with the member's own spend beside it, and the account is used up when
 the pool is.
 
+An Enterprise account's period has no Cursor Models, Other Models or Total
+in `GetCurrentPeriodUsage`: Cursor reports its overall allowance through
+the website's `usage-summary` instead. Magpie shows that as Enterprise,
+for example `49.45 / 800 USD · 6.2% used`, or
+`750.55 / 800 USD · 93.8% left` with Magpie's Used / Left choice, reset at
+the billing cycle's end. When the summary says team on-demand is enabled
+and unlimited or still has room, the Enterprise window is informational:
+reaching its included allowance doesn't count the account as used up.
+On-demand also shows the team's spend when known, with its limit when it
+has one. A reached on-demand limit counts the account as used up.
+
+### Included usage only (optional)
+
+In magpie, open the Cursor provider, turn on **Included usage only** under
+**Plugin options**, and save (or set `"pluginOptions": {"cursor":
+{"included_only": true}}` in magpie's settings.json). It is off by default,
+applies to every Cursor account, and takes effect at each account's next
+usage reading.
+
+When on, Cursor Models and Other Models (an Enterprise account's allowance)
+are what keep an account in routing: once one is used up, magpie moves its
+models to the next account until the period resets, even when on-demand
+could still pay for them. On-demand and Total are still shown but never
+keep an account in routing. Use it when on-demand is a shared or paid pool
+you don't want spent. When off, on-demand works as described above.
+
 Sign in to the Cursor account linked in Grok Bot. A linked SuperGrok
 subscription grants Bot access without a paid Cursor plan; see
 [Grok Bot plans and billing](https://cursor.com/help/grok-bot/plans).

package/index.mjs

@@ -532,15 +532,92 @@ async function hardLimit(tok) {
 // dollars, thousands grouped: a team's pool runs to six figures ($451,200.00)
 const dollars = (n) => "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })
 
-// usage is the account's windows this billing period; an enterprise plan
-// reports spend instead, and gets none. ids are the models it can be
-// asked for, each counted by the pool Cursor bills it to. An account that
-// may spend on-demand once its included usage is gone (fottencity on
+// INCLUDED_ONLY is the switch (magpie's plugin options, off by default)
+// that keeps an account in routing only while its included usage lasts
+// (magpie-community/plugins#485): on, the included pools (Cursor Models and
+// Other Models; an Enterprise account's allowance) are what stops it, and
+// On-demand and Total are shown only, a budget with room or none at all
+// keeping nothing in routing. Off, on-demand that can still pay keeps it.
+const INCLUDED_ONLY = "included_only"
+
+// enterpriseUsage is the allowance GetCurrentPeriodUsage leaves out on an
+// Enterprise account. That call answers with only the billing cycle there;
+// the website's usage-summary has individualUsage.overall, in cents, and
+// the account's membership. The CLI JWT is also the website's dashboard
+// session, as botUsage builds it. undefined when the summary says nothing
+// this can show, so a failed read stays an empty card, as before.
+async function enterpriseUsage(tok, includedOnly = false) {
+  try {
+    const subject = JSON.parse(Buffer.from(tok.split(".")[1], "base64url").toString()).sub
+    if (typeof subject !== "string") return undefined
+    const user = subject.split("|").filter(Boolean).at(-1)
+    if (!user || !/^[a-zA-Z0-9._-]+$/.test(user)) return undefined
+    const res = await fetch(WEBSITE + "/api/usage-summary", {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Origin: WEBSITE,
+        Cookie: "WorkosCursorSessionToken=" + encodeURIComponent(user + "::" + tok),
+      },
+      redirect: "error",
+      signal: AbortSignal.timeout(15_000),
+    })
+    if (!res.ok) return undefined
+    const data = await res.json()
+    if (String(data?.membershipType).toLowerCase() !== "enterprise") return undefined
+    const overall = data?.individualUsage?.overall
+    if (overall?.enabled !== true) return undefined
+    const { used, limit } = overall
+    if (typeof used !== "number" || !Number.isFinite(used) || used < 0) return undefined
+    if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) return undefined
+    const end = Date.parse(data.billingCycleEnd ?? "")
+    const resets = Number.isFinite(end) ? { resetsAt: new Date(end).toISOString() } : {}
+    const od = data.teamUsage?.onDemand
+    const spent = typeof od?.used === "number" && Number.isFinite(od.used) && od.used >= 0
+    const unlimited = od?.enabled === true && od.limit === null
+    const fixed = od?.enabled === true && typeof od.limit === "number" && Number.isFinite(od.limit) && od.limit > 0 && spent
+    // Only an explicitly unlimited budget or a measured budget with room
+    // lets a spent included allowance stay available to magpie's routing,
+    // and neither does with INCLUDED_ONLY on.
+    const aside = !includedOnly && (unlimited || (fixed && od.used < od.limit))
+    const windows = [{
+      name: "Enterprise",
+      used: Math.max(0, Math.min(100, (100 * used) / limit)),
+      display: `${dollars(used / 100)} / ${dollars(limit / 100)}`,
+      amount: used / 100,
+      limit: limit / 100,
+      unit: "USD",
+      ...resets,
+      ...(aside ? { aside: true } : {}),
+    }]
+    if (fixed) windows.push({
+      name: "On-demand",
+      used: Math.min(100, (100 * od.used) / od.limit),
+      display: `${dollars(od.used / 100)} / ${dollars(od.limit / 100)}`,
+      amount: od.used / 100,
+      limit: od.limit / 100,
+      unit: "USD",
+      ...resets,
+      ...(includedOnly ? { aside: true } : {}),
+    })
+    else if (unlimited && spent) windows.push({ name: "On-demand", used: 0, display: dollars(od.used / 100), ...resets, aside: true })
+    return windows
+  } catch {
+    return undefined
+  }
+}
+
+// usage is the account's windows this billing period. ids are the models it
+// can be asked for, each counted by the pool Cursor bills it to. An account
+// that may spend on-demand once its included usage is gone (fottencity on
 // Discord: a team that pays for more) is still served when the pools are
 // spent, so they are shown aside, and its On-demand spend is what can run
 // out: at its limit (a team member with none of their own: the team's
-// pool), or never when it has none.
-async function usage(tok, ids) {
+// pool), or never when it has none. With includedOnly (INCLUDED_ONLY on)
+// the pools are the allowance whatever on-demand allows, and On-demand is
+// shown only. An Enterprise account's period has no planUsage; its
+// allowance comes from usage-summary instead.
+async function usage(tok, ids, includedOnly = false) {
   const [res, hard] = await Promise.all([
     fetch(API + "/aiserver.v1.DashboardService/GetCurrentPeriodUsage", {
       method: "POST",
@@ -553,7 +630,11 @@ async function usage(tok, ids) {
   if (!res.ok) return { error: statusText(res.status), windows: [] }
   const data = await res.json()
   const u = data?.planUsage
-  if (!u) return { windows: [] }
+  if (!u) {
+    // Prefer measured Enterprise usage before any reset-date-only fallback.
+    const windows = await enterpriseUsage(tok, includedOnly)
+    return windows ? { windows } : { windows: [] }
+  }
   const ms = /^[+-]?\d+$/.test(data.billingCycleEnd ?? "") ? Number(data.billingCycleEnd) : 0
   const resets = ms > 0 ? { resetsAt: new Date(ms).toISOString() } : {}
   const bucket = new Set((data.autoBucketModels ?? []).map(poolBase))
@@ -573,10 +654,10 @@ async function usage(tok, ids) {
   const pool = [...new Set(["auto", ...asked, ...(data.autoBucketModels ?? [])])].filter(inPool)
   const num = (v) => (typeof v === "number" ? v : 0)
   const od = onDemandOf(data, hard)
-  const pooled = od.kind === "fixed" || od.kind === "unlimited" ? { aside: true } : {}
+  const pooled = !includedOnly && (od.kind === "fixed" || od.kind === "unlimited") ? { aside: true } : {}
   const onDemand =
     od.kind === "fixed"
-      ? [{ name: "On-demand", used: Math.max(0, Math.min(100, (100 * od.usedDollars) / od.limitDollars)), display: `${dollars(od.usedDollars)} / ${dollars(od.limitDollars)}` + (od.mineDollars === undefined ? "" : ` (you: ${dollars(od.mineDollars)})`), ...resets }]
+      ? [{ name: "On-demand", used: Math.max(0, Math.min(100, (100 * od.usedDollars) / od.limitDollars)), display: `${dollars(od.usedDollars)} / ${dollars(od.limitDollars)}` + (od.mineDollars === undefined ? "" : ` (you: ${dollars(od.mineDollars)})`), ...resets, ...(includedOnly ? { aside: true } : {}) }]
       : od.kind === "unlimited"
         ? [{ name: "On-demand", used: 0, display: dollars(od.usedDollars), ...resets, aside: true }]
         : []
@@ -3103,7 +3184,16 @@ async function answerOf(auth, chat, signal, session = "") {
 
 // ---- the plugin ---------------------------------------------------------------------------
 
-export async function CursorAuthPlugin() {
+export async function CursorAuthPlugin(input) {
+  // includedOnly is the user's INCLUDED_ONLY as magpie has it now, read at
+  // each usage reading so a change needs no restart; false outside magpie
+  const includedOnly = () => {
+    try {
+      return input?.magpie?.option?.(ID, INCLUDED_ONLY) === true
+    } catch {
+      return false
+    }
+  }
   return {
     auth: {
       provider: ID,
@@ -3136,6 +3226,16 @@ export async function CursorAuthPlugin() {
         { type: "oauth", label: "cursor-agent's sign-in", authorize: cliSignIn },
         { type: "api", label: "Cursor API key (cursor.com/dashboard → Integrations)" },
       ],
+      // magpie's own switches (input.magpie.option), read at each usage
+      // reading
+      options: [
+        {
+          key: INCLUDED_ONLY,
+          label: "Included usage only",
+          description:
+            "Keeps an account in routing only while its included usage lasts: once Cursor Models or Other Models is used up, magpie moves those models to the next account until the period resets, even if on-demand could pay. On-demand and Total are still shown but never keep an account in routing.",
+        },
+      ],
       // magpie's: how much of the plan's included usage is gone (the plan
       // is the one the sign-in read). The built-in's read, clean or not,
       // neither marked the account nor cleared it.
@@ -3146,7 +3246,7 @@ export async function CursorAuthPlugin() {
         } catch (e) {
           return { error: e.message, windows: [], signIn: "kept" }
         }
-        const [u, plan, bot] = await Promise.all([usage(tok, Object.keys(provider?.models ?? {})), planOf(tok), botUsage(tok)])
+        const [u, plan, bot] = await Promise.all([usage(tok, Object.keys(provider?.models ?? {}), includedOnly()), planOf(tok), botUsage(tok)])
         // Bot goes among magpie's three menu-bar rings: before Total, and
         // before an On-demand with no limit, which is only a dollar figure on
         // a ring that never fills (magpie #2213, Morganwan90). An On-demand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-cursor-auth",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "description": "Cursor subscriptions (Pro, Pro+, Ultra, Teams) in OpenCode and magpie, through the API cursor-agent talks to",
   "type": "module",
   "main": "./index.mjs",