clauddy 1.26.0 → 1.28.0

package/README.md

@@ -1,6 +1,6 @@
 # 🟫 Clauddy
 
-A cute pixel-art desktop pet for macOS that tracks your Claude Code usage — mirroring the official **Settings → Usage** panel (current session + weekly limits, in tokens & %), with animations. Use Codex too? It can track that alongside (see [Codex](#codex)).
+A cute pixel-art desktop pet for macOS that tracks your Claude Code usage — mirroring the official **Settings → Usage** panel (current session + weekly limits, in tokens & %), with animations. Use Codex or Cursor too? It can track those alongside (see [Codex](#codex) and [Cursor](#cursor)).
 
 <p align="center">
 
@@ -53,6 +53,21 @@ A few things differ from Claude:
 
 Disconnecting (the **×** on the Codex card) only stops monitoring in Clauddy; your Codex login and logs are untouched.
 
+## Cursor
+
+Clauddy can follow [Cursor](https://cursor.com) too. Open **⚙ Settings → Connections → Cursor → Connect**: it needs the Cursor app signed in on this computer, and starts monitoring once it finds that login. Clauddy reads the app's session token from its local storage and asks Cursor's own dashboard endpoints for your usage, the same numbers as the Usage page on cursor.com.
+
+With three services connected, the tabs under the pet show each logo and %, and the minimized dock gets a third line.
+
+Cursor works differently from the other two:
+
+- **Its budget is monthly.** The Cursor tab shows **this month · included** (the whole plan) and **API models** (the pool for named third-party models), both resetting on your billing date. There is no 5-hour session or weekly window.
+- **Activity scenes work.** Cursor's agent writes a transcript of every tool call under `~/.cursor/projects`, so the pet reads, edits, runs commands and researches along with it, as it does for Claude.
+- **No token counts.** Neither source reports tokens, so the Cursor tab has no breakdowns or 30-day map, and its status line says when the agent last ran instead.
+- **The endpoints are unofficial.** They're the ones the cursor.com dashboard uses, checked every 5 minutes. If Cursor changes them, the tab shows the last reading with its age until Clauddy is updated.
+
+Disconnecting (the **×** on the Cursor card) only stops monitoring in Clauddy; the Cursor app and its login are untouched.
+
 ## Burn rate
 
 Knowing you're at **82%** with **1h 12m** left on the window still leaves you doing arithmetic in your head. So Clauddy does it for you: it fits the slope of your recent usage and projects when you'd hit 100% — showing one extra line under the session bar:
@@ -123,6 +138,7 @@ Now and then the pet says something in a speech bubble. It only speaks when some
 | 90 minutes of unbroken work | _You've been at it for 1h 35m straight. Stretch break?_ | _Stretch break?_ | |
 | A new record day (30-day best) | _New record! 45M tokens today, your biggest day in a month._ | _New record: 45M!_ | |
 | Codex crosses fire, hits 100%, or resets | _Codex is at 91% now. It resets in 1h 12m._ | _Codex at 91%!_ | ✓ (fire, reset) |
+| Cursor crosses fire, hits 100%, or starts a new month | _Cursor is at 91% now. It resets in 6d 4h._ | _Cursor at 91%!_ | ✓ (fire, reset) |
 
 The greeting follows your clock (_Good morning_, _Good afternoon_, _Good evening_, or _Still up?_ before 5 AM) and appears once a day, and so does the record. The reset recap covers only what the pet actually saw, so if you launch it mid-session it says less. Click the bubble to dismiss it.
 
@@ -214,8 +230,8 @@ update-desktop-database ~/.local/share/applications 2>/dev/null
 ## Controls
 
 - **Drag** the widget anywhere on screen
-- **–** minimizes to just the pet, ringed by the live session % (the number sits inside the ring) — or, with Claude and Codex both connected, one reading per service; the **⤢** button or a double-click on the pet expands it back
-- **Pet icon** in the compact header switches to **Just the pet** (floating mode). Drag the pet itself to move it. Hovering over the pet (or focusing it) reveals the usage glance; the small expand button in it returns to compact. Keyboard users can focus the pet and press Enter. The chosen size is remembered. In compact and pet-only modes, the pet follows whoever is working, with provider logos identifying Claude, Codex, or both. Usage selection stays manual; when neither is active the pet rests.
+- **–** minimizes to just the pet, ringed by the live session % (the number sits inside the ring) — or, with more than one service connected, one reading per service; the **⤢** button or a double-click on the pet expands it back
+- **Pet icon** in the compact header switches to **Just the pet** (floating mode). Drag the pet itself to move it. Hovering over the pet (or focusing it) reveals the usage glance; the small expand button in it returns to compact. Keyboard users can focus the pet and press Enter. The chosen size is remembered. In compact and pet-only modes, the pet follows whoever is working, with provider logos identifying Claude, Codex, Cursor, or several at once. Usage selection stays manual. When neither is active, the hottest session still sets the mood: the pet catches fire (or maxes out) with that provider's logo beside it, and otherwise rests.
 - **⚙** opens settings (log in, toggle alerts, set thresholds, pick the display mode)
 - **↗** opens the official Usage page of the service on screen
 - **×** quits
@@ -225,7 +241,7 @@ update-desktop-database ~/.local/share/applications 2>/dev/null
 Under **⚙ Settings → Preferences** you can pick where Clauddy lives:
 
 - **Floating pet** — the always-on widget in the corner (default).
-- **Menu bar** — a small pet icon in the macOS menu bar showing your live session **%** (it turns 🔥 near your limit; with Codex too it reads `C 64% · X 28%`). Click it to pop open the full pet + usage panel; click away to dismiss. Right-click for a quick menu.
+- **Menu bar** — a small pet icon in the macOS menu bar showing your live session **%** (it turns 🔥 near your limit; with Codex or Cursor too it reads `C 64% · X 28% · Cu 5%`). Click it to pop open the full pet + usage panel; click away to dismiss. Right-click for a quick menu.
 
 Switching is instant — no restart. (On Windows/Linux the icon lives in the system tray; the live % shows in its tooltip.)
 
@@ -243,6 +259,7 @@ Optional **macOS notifications**, toggled (with their thresholds) in **⚙ Setti
 | _Weekly usage at 84%_ — `resets Fri 7:00 AM` | Same, for the weekly limit |
 | _Fable weekly at 84%_ — `resets Fri 7:00 AM` | Same, for a per-model weekly limit |
 | _Codex session at 82%_ / _Codex weekly at 84%_ | Same, for Codex, when it's connected |
+| _Cursor usage at 82%_ / _Cursor API models at 84%_ — `resets Oct 11` | Same, for Cursor's month, when it's connected |
 | _Session window reset_ — `full budget again` | A session you had pushed past 80% rolls over |
 | _Clauddy lost access to your usage_ | The OAuth token expired or was revoked, so the % went back to being an estimate |
 
@@ -256,7 +273,7 @@ The first alert asks macOS for permission; after that the app shows up in **Syst
 
 When the selected session crosses your first alert threshold, **Notify at reset** appears beneath the session details and in the compact monitor. Click to arm it; click **Reminder on** to cancel. This is a one-shot request, independent of the automatic threshold-alert toggle.
 
-Reminders survive restarts, belong to the Claude account or Codex connection that created them, and are canceled when you disconnect that source. Clauddy must be running to notify; an overdue reminder is delivered on reopening or waking up. A fresh, lower reading confirms that session budget returned and the pet celebrates. If usage hasn't refreshed — common with idle Codex logs — the reminder only says the scheduled reset time arrived and asks you to check usage.
+Reminders survive restarts, belong to the Claude account, Codex or Cursor connection that created them, and are canceled when you disconnect that source. Clauddy must be running to notify; an overdue reminder is delivered on reopening or waking up. A fresh, lower reading confirms that session budget returned and the pet celebrates. If usage hasn't refreshed — common with idle Codex logs — the reminder only says the scheduled reset time arrived and asks you to check usage.
 
 ## Configure (`config.json`)
 
@@ -272,6 +289,7 @@ Settings saved from the UI live in `~/.claude-usage-monitor/config.json`, so you
   "activeThresholdMs": 20000, // "active" if Claude wrote to its logs within this window
   "sleepThresholdMs": 300000, // "sleeping" after this much idle time (5 min)
   "codex": { "enabled": false }, // set by Settings → Codex → Connect
+  "cursor": { "enabled": false }, // set by Settings → Cursor → Connect
   "talk": true, // speech bubbles on transitions
   "sound": false, // chiptune blips, opt-in
   "soundMutedUntil": 0, // set by the 🔊 button: muted until this epoch ms
@@ -292,7 +310,7 @@ bunx clauddy tired       # 🥵 maxed out
 bunx clauddy idle        # 🙂 calm
 bunx clauddy auto        # ↩️ back to your real usage
 bunx clauddy say         # 💬 a remark in the speech bubble
-bunx clauddy say fire    #    or a specific one: greeting, fire, reset, maxed, welcome, streak, record, codex
+bunx clauddy say fire    #    or a specific one: greeting, fire, reset, maxed, welcome, streak, record, codex, cursor
 ```
 
 Each state is written to the data dir the running widget watches, so it reacts
@@ -316,11 +334,11 @@ Everything lives on your machine, in `~/.claude-usage-monitor/`:
 - `alerts.json` — which notifications are already armed, so a restart doesn't repeat them
 - `accounts.json` — your list of accounts and which one is active
 
-With Codex connected, Clauddy also reads (never writes) `~/.codex/sessions`.
+With Codex connected, Clauddy also reads (never writes) `~/.codex/sessions`. With Cursor connected, it reads the Cursor app's login from its local storage and the agent transcripts in `~/.cursor/projects`, also without writing.
 - `debug.json` — scratch file for the `./pet` simulator
 - `accounts/<id>/` — the same `auth.json` + `alerts.json`, for each extra account
 
-Nothing leaves your machine except the OAuth calls to Anthropic's own login and usage endpoints.
+Nothing leaves your machine except the OAuth calls to Anthropic's own login and usage endpoints, and, with Cursor connected, the usage calls to Cursor's own API with the Cursor app's token.
 
 ## Contributing
 

package/bin/clauddy.js

@@ -33,7 +33,17 @@ const STATES = [
   'waiting',
 ]
 // `clauddy say <kind>` previews one of the pet's remarks
-const REMARKS = ['greeting', 'fire', 'reset', 'maxed', 'welcome', 'streak', 'record', 'codex']
+const REMARKS = [
+  'greeting',
+  'fire',
+  'reset',
+  'maxed',
+  'welcome',
+  'streak',
+  'record',
+  'codex',
+  'cursor',
+]
 const arg = process.argv[2]
 const kind = arg === 'say' ? process.argv[3] || 'greeting' : undefined
 

package/cursor.js

@@ -0,0 +1,267 @@
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+
+// Cursor keeps no usage in local files. Its app stores a session token in
+// `state.vscdb` (SQLite), and the same dashboard endpoints cursor.com uses
+// answer with it — unofficial, so every field is read defensively. Activity
+// comes from the agent transcripts under ~/.cursor/projects, which log each
+// tool call much like Claude Code's own logs.
+const API = 'https://api2.cursor.sh/aiserver.v1.DashboardService/'
+const ACTIVE_MS = 60000 // a transcript touched within the last minute = Cursor working
+const FETCH_MS = 5 * 60000 // a monthly budget moves slowly; don't hammer the API
+const RETRY_MS = 60000
+const TAIL_BYTES = 64 * 1024
+
+function defaultStateDb() {
+  const tail = ['Cursor', 'User', 'globalStorage', 'state.vscdb']
+  if (process.platform === 'darwin')
+    return path.join(os.homedir(), 'Library', 'Application Support', ...tail)
+  if (process.platform === 'win32')
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), ...tail)
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), ...tail)
+}
+
+let homeDir = path.join(os.homedir(), '.cursor')
+let stateDb = defaultStateDb()
+let fetchImpl = (...args) => globalThis.fetch(...args)
+let limits = null // last good reading: { ts, plan, endMs, total, api }
+let lastTry = -Infinity
+let lastFailed = false
+let signedOut = false
+let inflight = null
+
+// tests point these elsewhere; a change of place forgets the old reading
+function configureCursor(opts = {}) {
+  if ('fetch' in opts) fetchImpl = opts.fetch || ((...args) => globalThis.fetch(...args))
+  if (!('home' in opts) && !('stateDb' in opts)) return
+  if ('home' in opts) homeDir = opts.home || path.join(os.homedir(), '.cursor')
+  if ('stateDb' in opts) stateDb = opts.stateDb || defaultStateDb()
+  limits = null
+  lastTry = -Infinity
+  lastFailed = false
+  signedOut = false
+  inflight = null
+}
+
+const text = (v) => (v == null ? null : typeof v === 'string' ? v : Buffer.from(v).toString('utf8'))
+
+// Electron's Node has `node:sqlite`; Bun, which runs the tests, has its own
+// with the same prepare/get/close
+function openReadOnly(file) {
+  try {
+    const { DatabaseSync } = require('node:sqlite')
+    return new DatabaseSync(file, { readOnly: true })
+  } catch (err) {
+    if (!process.versions.bun) throw err
+    const { Database } = require('bun:sqlite')
+    return new Database(file, { readonly: true })
+  }
+}
+
+// the app's own session: its token, plus the plan it last cached
+function readAuth() {
+  if (!fs.existsSync(stateDb)) return null
+  let db
+  try {
+    db = openReadOnly(stateDb)
+    const q = db.prepare('SELECT value FROM ItemTable WHERE key = ?')
+    const get = (k) => text(q.get(k)?.value)
+    return { token: get('cursorAuth/accessToken'), plan: get('cursorAuth/stripeMembershipType') }
+  } catch {
+    return null
+  } finally {
+    db?.close()
+  }
+}
+
+// Settings → Connect: only a signed-in app has something to read
+function detectCursor() {
+  const auth = readAuth()
+  return { found: !!auth?.token, plan: auth?.plan || null }
+}
+
+async function post(method, token) {
+  const res = await fetchImpl(API + method, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      'Connect-Protocol-Version': '1',
+    },
+    body: '{}',
+    signal: AbortSignal.timeout(15000),
+  })
+  if (!res.ok) throw new Error(`cursor ${method}: HTTP ${res.status}`)
+  return res.json()
+}
+
+const pctOf = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null)
+
+// One fetch at a time. The token is read fresh each time: the Cursor app
+// refreshes it on its own, so there is nothing to renew here.
+function refreshLimits(now = Date.now()) {
+  if (inflight) return inflight
+  lastTry = now
+  inflight = (async () => {
+    const auth = readAuth()
+    signedOut = !auth?.token
+    if (signedOut) return
+    const [usage, info] = await Promise.all([
+      post('GetCurrentPeriodUsage', auth.token),
+      post('GetPlanInfo', auth.token).catch(() => null),
+    ])
+    const pu = usage?.planUsage || {}
+    limits = {
+      ts: now,
+      plan: info?.planInfo?.planName?.toLowerCase() || auth.plan || null,
+      endMs: Number(usage?.billingCycleEnd) || null,
+      total: pctOf(pu.totalPercentUsed),
+      api: pctOf(pu.apiPercentUsed),
+    }
+  })()
+    .then(() => {
+      lastFailed = false
+    })
+    .catch((err) => {
+      lastFailed = true
+      console.error('cursor:', err.message)
+    })
+    .finally(() => {
+      inflight = null
+    })
+  return inflight
+}
+
+// the billing cycle as a window; past its end, the % belongs to the old cycle
+function cycleNow(pct, endMs, now) {
+  const expired = endMs != null && endMs <= now
+  return {
+    pct: expired ? null : pct,
+    resetMs: endMs != null && !expired ? endMs - now : null,
+    expired,
+  }
+}
+
+// ---- activity ---------------------------------------------------------------
+const ACTIVITY = {
+  Read: 'reading',
+  ReadFile: 'reading',
+  Grep: 'reading',
+  Glob: 'reading',
+  LS: 'reading',
+  ListDir: 'reading',
+  SemanticSearch: 'reading',
+  ReadLints: 'reading',
+  Write: 'editing',
+  StrReplace: 'editing',
+  Edit: 'editing',
+  MultiEdit: 'editing',
+  ApplyPatch: 'editing',
+  Delete: 'editing',
+  EditNotebook: 'editing',
+  Shell: 'running',
+  WebSearch: 'researching',
+  WebFetch: 'researching',
+  Task: 'delegating',
+  TodoWrite: 'planning',
+  CreatePlan: 'planning',
+  AskQuestion: 'waiting',
+}
+
+// what the newest transcript lines say: a finished turn means nothing is running
+function activityOf(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let o
+    try {
+      o = JSON.parse(lines[i])
+    } catch {
+      continue
+    }
+    if (o.type === 'turn_ended') return null
+    if (o.role === 'assistant') {
+      const blocks = Array.isArray(o.message?.content) ? o.message.content : []
+      const tool = blocks.findLast((b) => b?.type === 'tool_use')
+      return (tool && ACTIVITY[tool.name]) || 'working'
+    }
+    if (o.role === 'user') return 'working' // just asked: the agent is thinking
+  }
+  return 'working'
+}
+
+const dirs = (dir) => {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith('.'))
+  } catch {
+    return []
+  }
+}
+
+// every transcript, subagents included: projects/<p>/agent-transcripts/<id>/…
+function transcripts() {
+  const out = []
+  for (const p of dirs(path.join(homeDir, 'projects'))) {
+    if (!p.isDirectory()) continue
+    const root = path.join(homeDir, 'projects', p.name, 'agent-transcripts')
+    for (const id of dirs(root)) {
+      if (!id.isDirectory()) continue
+      const dir = path.join(root, id.name)
+      for (const f of dirs(dir)) {
+        if (f.isFile() && f.name.endsWith('.jsonl')) out.push(path.join(dir, f.name))
+        else if (f.isDirectory() && f.name === 'subagents') {
+          for (const s of dirs(path.join(dir, f.name)))
+            if (s.isFile() && s.name.endsWith('.jsonl')) out.push(path.join(dir, f.name, s.name))
+        }
+      }
+    }
+  }
+  return out
+}
+
+function tailLines(file, size) {
+  const len = Math.min(size, TAIL_BYTES)
+  const buf = Buffer.alloc(len)
+  const fd = fs.openSync(file, 'r')
+  try {
+    fs.readSync(fd, buf, 0, len, size - len)
+  } finally {
+    fs.closeSync(fd)
+  }
+  const lines = buf.toString('utf8').split('\n')
+  if (len < size) lines.shift() // cut mid-line
+  return lines.filter(Boolean)
+}
+
+function readActivity(now) {
+  let latest = null
+  for (const file of transcripts()) {
+    try {
+      const st = fs.statSync(file)
+      if (!latest || st.mtimeMs > latest.st.mtimeMs) latest = { file, st }
+    } catch {}
+  }
+  if (!latest) return { active: false, activity: null, lastSeen: null }
+  const lastSeen = latest.st.mtimeMs
+  if (now - lastSeen >= ACTIVE_MS) return { active: false, activity: null, lastSeen }
+  let activity = 'working'
+  try {
+    activity = activityOf(tailLines(latest.file, latest.st.size))
+  } catch {}
+  return { active: activity != null, activity, lastSeen }
+}
+
+// The poll's view of Cursor: activity from disk every tick, limits from the
+// last fetch (a new one starts in the background when it's due).
+function getCursorUsage(now = Date.now()) {
+  if (now - lastTry >= (limits && !lastFailed ? FETCH_MS : RETRY_MS)) refreshLimits(now)
+  return {
+    ...readActivity(now),
+    plan: limits?.plan ?? null,
+    session: limits ? cycleNow(limits.total, limits.endMs, now) : null,
+    api: limits ? cycleNow(limits.api, limits.endMs, now) : null,
+    limitsAt: limits?.ts ?? null,
+    signedOut,
+  }
+}
+
+module.exports = { getCursorUsage, refreshLimits, detectCursor, configureCursor, activityOf }

package/main.js

@@ -19,12 +19,14 @@ const { getUsage } = usage
 const auth = require('./auth')
 const accounts = require('./accounts')
 const codex = require('./codex')
+const cursor = require('./cursor')
 const { createReminders } = require('./reminders')
 
 const REPO = 'renatoaug/claude-usage-monitor'
 const USAGE_URLS = {
   claude: 'https://claude.ai/settings/usage',
   codex: 'https://chatgpt.com/usage#settings/Usage',
+  cursor: 'https://cursor.com/dashboard?tab=usage',
 }
 
 // data dir: kept outside the project folder so moving the repo doesn't break it.
@@ -65,6 +67,8 @@ let sessionPct = null // authoritative session % shown in the tray title
 let codexUsage = null // last Codex payload, null while it isn't enabled
 let realUsageAt = 0
 let codexReadAt = 0
+let cursorUsage = null // last Cursor payload, null while it isn't enabled
+let cursorReadAt = 0
 let realUsage = null // last OAuth usage payload — the % alerts trust when logged in
 let lastProgrammaticMove = 0 // ignore the 'moved' event our own setPosition triggers
 let displayChanging = 0 // ignore OS window-shuffles while a display (dis)connects
@@ -81,6 +85,7 @@ function publicConfig(c) {
     fireThreshold: c.fireThreshold,
     zoom: c.zoom,
     codex: !!c.codex?.enabled,
+    cursor: !!c.cursor?.enabled,
     talk: c.talk,
     sound: c.sound,
     soundMutedUntil: c.soundMutedUntil,
@@ -99,6 +104,7 @@ function loadConfig() {
     fireThreshold: 90, // session % at which the pet catches fire (tired still fixed at 100)
     zoom: 100, // widget scale %, 100-200
     codex: { enabled: false }, // opt-in from Settings, never on by finding ~/.codex
+    cursor: { enabled: false }, // opt-in too: it reads the Cursor app's own login
     talk: true, // speech bubbles on transitions
     sound: false, // chiptune blips: opt-in, audio must never surprise anyone
     soundMutedUntil: 0, // the one-click "mute for 1 hour", as an epoch ms
@@ -147,6 +153,8 @@ function fmtDuration(ms) {
 function fmtClock(ms) {
   const at = new Date(Date.now() + ms)
   const time = at.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' })
+  // a week or more out (Cursor's monthly cycle), a weekday would be ambiguous
+  if (ms >= 6 * 86400000) return at.toLocaleDateString([], { month: 'short', day: 'numeric' })
   return ms >= 86400000 ? `${at.toLocaleDateString([], { weekday: 'short' })} ${time}` : time
 }
 
@@ -169,12 +177,35 @@ const resetReminders = createReminders({
     fs.renameSync(tmp, REMINDERS_FILE)
   },
 })
-const reminderKey = (provider) => (provider === 'codex' ? 'codex' : `claude:${accounts.activeId()}`)
+// Codex and Cursor have one connection each; Claude's reminders are per account
+const reminderKey = (provider) =>
+  provider === 'claude' ? `claude:${accounts.activeId()}` : provider
+const NAMES = { claude: 'Claude', codex: 'Codex', cursor: 'Cursor' }
+// each service's reset window, when it was read, and whether it's still on
+function serviceState(provider) {
+  if (provider === 'codex')
+    return {
+      session: codexUsage?.session,
+      readAt: codexReadAt,
+      freshAt: codexUsage?.limitsAt,
+      on: !!config.codex?.enabled,
+    }
+  if (provider === 'cursor')
+    return {
+      session: cursorUsage?.session,
+      readAt: cursorReadAt,
+      freshAt: cursorUsage?.limitsAt,
+      on: !!config.cursor?.enabled,
+    }
+  return { session: realUsage?.session, readAt: realUsageAt, freshAt: realUsageAt, on: null }
+}
 function sendReminders(error = null) {
   if (!win || win.isDestroyed()) return
+  const find = (p) => resetReminders.list().find((r) => r.key === reminderKey(p)) || null
   win.webContents.send('reminders', {
-    claude: resetReminders.list().find((r) => r.key === reminderKey('claude')) || null,
-    codex: resetReminders.list().find((r) => r.key === 'codex') || null,
+    claude: find('claude'),
+    codex: find('codex'),
+    cursor: find('cursor'),
     error,
   })
 }
@@ -193,16 +224,15 @@ function checkResetReminders() {
   try {
     for (const r of resetReminders.list()) {
       const connected =
-        r.provider === 'codex'
-          ? config.codex?.enabled
-          : accounts.list().some((a) => r.key === `claude:${a.id}` && hasToken(a.id))
+        r.provider === 'claude'
+          ? accounts.list().some((a) => r.key === `claude:${a.id}` && hasToken(a.id))
+          : serviceState(r.provider).on
       if (!connected && !cancelReminder(r.key)) return
     }
     const due = resetReminders.takeDue()
     for (const r of due) {
-      const isCurrent = r.provider === 'codex' || r.key === reminderKey('claude')
-      const session = r.provider === 'codex' ? codexUsage?.session : realUsage?.session
-      const readAt = r.provider === 'codex' ? codexUsage?.limitsAt : realUsageAt
+      const isCurrent = r.provider !== 'claude' || r.key === reminderKey('claude')
+      const { session, freshAt: readAt } = serviceState(r.provider)
       const confirmed = isCurrent && readAt >= r.at && session?.pct != null && session.pct < r.pct
       const message = confirmed
         ? `${r.label}: session budget is available again.`
@@ -220,14 +250,12 @@ function checkResetReminders() {
   }
 }
 ipcMain.on('set-reminder', (_e, provider, enabled) => {
-  if (!['claude', 'codex'].includes(provider) || typeof enabled !== 'boolean') return
+  if (!Object.hasOwn(NAMES, provider) || typeof enabled !== 'boolean') return
   const key = reminderKey(provider)
   if (!enabled) return cancelReminder(key)
-  const cx = provider === 'codex'
-  const session = cx ? codexUsage?.session : realUsage?.session
-  const at = (cx ? codexReadAt : realUsageAt) + (session?.resetMs || 0)
-  const freshAt = cx ? codexUsage?.limitsAt : realUsageAt
-  const connected = cx ? config.codex?.enabled : auth.isConnected()
+  const { session, readAt, freshAt, on } = serviceState(provider)
+  const at = readAt + (session?.resetMs || 0)
+  const connected = provider === 'claude' ? auth.isConnected() : on
   if (
     !connected ||
     !freshAt ||
@@ -237,7 +265,10 @@ ipcMain.on('set-reminder', (_e, provider, enabled) => {
     return sendReminders('Wait for a fresh usage reading before setting a reminder.')
   }
   try {
-    const label = cx ? 'Codex' : `Claude · ${accounts.active().label || 'your account'}`
+    const label =
+      provider === 'claude'
+        ? `Claude · ${accounts.active().label || 'your account'}`
+        : NAMES[provider]
     if (!resetReminders.arm({ key, provider, label, at, pct: session.pct })) {
       return sendReminders('This reset time has passed. Wait for a fresh reading.')
     }
@@ -305,6 +336,14 @@ function checkCodexAlerts(config, c) {
     { label: 'Codex weekly', pct: c.weekly?.pct, resetMs: c.weekly?.resetMs },
   ])
 }
+// Cursor's budget is the billing cycle; its API-model pool fills on its own
+function checkCursorAlerts(config, c) {
+  if (!c) return
+  alertScopes(config, [
+    { label: 'Cursor usage', pct: c.session?.pct, resetMs: c.session?.resetMs },
+    { label: 'Cursor API models', pct: c.api?.pct, resetMs: c.api?.resetMs },
+  ])
+}
 // per-model weekly limits only exist on the account side, so they're checked
 // off the OAuth poll rather than the local tick
 function checkScopedAlerts(config, u) {
@@ -550,6 +589,17 @@ function createWindow() {
     } catch (err) {
       console.error('codex:', err)
     }
+    // Cursor too: limits come from a throttled background fetch
+    try {
+      const c = config.cursor?.enabled ? cursor.getCursorUsage() : null
+      cursorUsage = c
+      cursorReadAt = Date.now()
+      win.webContents.send('cursor', c)
+      checkCursorAlerts(config, c)
+      updateTray()
+    } catch (err) {
+      console.error('cursor:', err)
+    }
     checkResetReminders()
   }
   doTick = tick
@@ -641,11 +691,13 @@ function trayMenu() {
   return Menu.buildFromTemplate([
     { label: 'Open Clauddy', click: () => showPopover() },
     ...accountsMenuItems(),
-    ...(config.codex?.enabled
-      ? [
-          { label: 'Open Claude usage', click: () => shell.openExternal(USAGE_URLS.claude) },
-          { label: 'Open Codex usage', click: () => shell.openExternal(USAGE_URLS.codex) },
-        ]
+    ...(config.codex?.enabled || config.cursor?.enabled
+      ? ['claude', 'codex', 'cursor']
+          .filter((p) => p === 'claude' || config[p]?.enabled)
+          .map((p) => ({
+            label: `Open ${NAMES[p]} usage`,
+            click: () => shell.openExternal(USAGE_URLS[p]),
+          }))
       : [{ label: 'Open Usage page', click: () => shell.openExternal(USAGE_URLS.claude) }]),
     { type: 'separator' },
     { label: 'Quit Clauddy', click: () => app.quit() },
@@ -742,15 +794,19 @@ function positionFloating() {
 function updateTray() {
   if (!tray) return
   const cx = codexUsage
-  const cxPct = cx?.session?.pct
-  // both services: one icon, both numbers, each labelled — never one blended %
-  if (cx) {
+  const cu = cursorUsage
+  // several services: one icon, every number labelled — never one blended %
+  if (cx || cu) {
     const fmt = (v) => (v == null ? '—' : `${Math.round(v)}%`)
-    const title = sessionPct == null ? `X ${fmt(cxPct)}` : `C ${fmt(sessionPct)} · X ${fmt(cxPct)}`
+    const age = (u) => (u.limitsAt ? ` (as of ${new Date(u.limitsAt).toLocaleTimeString()})` : '')
+    const parts = [
+      sessionPct != null && ['C', `Claude session ${fmt(sessionPct)}`, sessionPct],
+      cx && ['X', `Codex session ${fmt(cx.session?.pct)}${age(cx)}`, cx.session?.pct],
+      cu && ['Cu', `Cursor usage ${fmt(cu.session?.pct)}${age(cu)}`, cu.session?.pct],
+    ].filter(Boolean)
+    const title = parts.map(([k, , v]) => `${k} ${fmt(v)}`).join(' · ')
     if (process.platform === 'darwin') tray.setTitle(` ${title}`)
-    const age = cx.limitsAt ? ` (as of ${new Date(cx.limitsAt).toLocaleTimeString()})` : ''
-    const claude = sessionPct == null ? '' : `Claude session ${fmt(sessionPct)} · `
-    tray.setToolTip(`Clauddy — ${claude}Codex session ${fmt(cxPct)}${age}`)
+    tray.setToolTip(`Clauddy — ${parts.map(([, t]) => t).join(' · ')}`)
     return
   }
   if (sessionPct == null) {
@@ -836,6 +892,16 @@ ipcMain.on('codex-detect', () => {
 })
 ipcMain.on('codex-enable', (_e, on) => setCodexEnabled(!!on))
 
+// Settings → Connect Cursor: it needs the Cursor app signed in on this machine
+ipcMain.on('cursor-detect', () => {
+  let r = { found: false, plan: null }
+  try {
+    r = cursor.detectCursor()
+  } catch {}
+  if (win && !win.isDestroyed()) win.webContents.send('cursor-detected', r)
+})
+ipcMain.on('cursor-enable', (_e, on) => setCursorEnabled(!!on))
+
 // watch the debug file; forward forced states to the renderer
 function watchDebug() {
   fs.watchFile(DEBUG_FILE, { interval: 400 }, () => {
@@ -1032,6 +1098,19 @@ function setCodexEnabled(on) {
   updateTray()
 }
 
+// off only stops monitoring here; the Cursor app and its login are untouched
+function setCursorEnabled(on) {
+  writeConfigPatch({ cursor: { ...(config.cursor || {}), enabled: on } })
+  config = loadConfig()
+  if (!on) {
+    cursorUsage = null
+    cancelReminder('cursor')
+  }
+  if (win && !win.isDestroyed()) win.webContents.send('config', publicConfig(config))
+  if (doTick) doTick()
+  updateTray()
+}
+
 function writeConfigPatch(patch) {
   let obj = {}
   for (const p of [EXTERNAL_CONFIG, path.join(__dirname, 'config.json')]) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clauddy",
   "desktopName": "clauddy.desktop",
-  "version": "1.26.0",
+  "version": "1.28.0",
   "description": "A cute desktop pet that tracks your Claude Code usage",
   "main": "main.js",
   "bin": {
@@ -15,6 +15,7 @@
     "auth.js",
     "accounts.js",
     "codex.js",
+    "cursor.js",
     "reminders.js",
     "config.json",
     "renderer"
@@ -76,6 +77,7 @@
       "auth.js",
       "accounts.js",
       "codex.js",
+      "cursor.js",
       "reminders.js",
       "config.json",
       "renderer/**",