clauddy 1.23.1 → 1.24.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.
+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)).
 
 <p align="center">
 
@@ -24,7 +24,7 @@ The **percentages are real**, pulled from your account (you log in once — see
 
 The session/weekly **%** comes straight from your Anthropic account, so it matches the official panel exactly. You connect once via a browser login:
 
-1. Open **⚙ Settings → "Log in with browser"** — your browser opens an Anthropic auth page.
+1. Open **⚙ Settings → Connections → Claude → Connect** — your browser opens an Anthropic auth page.
 2. Log in, copy the **authentication code** shown, and paste it back into the app → **Connect**.
 
 The token is saved locally (see [Data & privacy](#data--privacy)) and refreshed automatically. **Until you connect**, the limits area shows a _"Connect your account"_ prompt instead of percentages.
@@ -39,6 +39,20 @@ Removing an account (the **×** on its row) deletes its token from disk. The one
 
 > Prefer one widget per account instead? Setting `CLAUDE_CONFIG_DIR` still isolates a whole instance — token, settings and logs — so you can run two Clauddys side by side.
 
+## Codex
+
+Clauddy can follow [Codex](https://openai.com/codex) (the CLI and the desktop app) next to Claude. Open **⚙ Settings → Connections → Codex → Connect**: it looks for a Codex session on this computer and starts monitoring if it finds one. There's nothing to log into — Codex writes its token counts and rate limits to `~/.codex/sessions` (or `$CODEX_HOME`), and Clauddy only reads those files.
+
+With both connected, **tabs under the pet** pick which service the whole panel shows — account chip, pet mood, session and weekly %, the breakdowns, the 30-day map and the **↗** Usage link. The other tab keeps its % in view and gets a **!** when it crosses an alert threshold. Minimized, the ring becomes one reading per service; click one to switch.
+
+A few things differ from Claude:
+
+- **The % updates when Codex runs.** Its logs are only written during a session, so an idle Codex shows the last reading with its age (`read 1h 30m ago`). A window that has already reset since then shows **—** rather than a made-up 0%.
+- **It can lag the account page.** Codex limits are shared with other ChatGPT products (Work, Agents, Excel) that don't write to these logs.
+- **No burn-rate projection and no activity scenes** — the logs don't carry enough to draw them honestly.
+
+Disconnecting (the **×** on the Codex card) only stops monitoring in Clauddy; your Codex login and logs 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:
@@ -171,17 +185,17 @@ 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); the **⤢** button or a double-click on the pet expands it back
+- **–** 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
 - **⚙** opens settings (log in, toggle alerts, set thresholds, pick the display mode)
-- **↗** opens the official Usage page
+- **↗** opens the official Usage page of the service on screen
 - **×** quits
 
 ### Floating or menu bar
 
-Under **⚙ Settings → Display** you can pick where Clauddy lives:
+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). 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 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.
 
 Switching is instant — no restart. (On Windows/Linux the icon lives in the system tray; the live % shows in its tooltip.)
 
@@ -194,6 +208,7 @@ Optional **macOS notifications**, toggled (with their thresholds) in **⚙ Setti
 | _Session at 82%_ — `2h 39m left · resets 6:50 PM` | Your session crosses a threshold (default **80%** and **95%**) |
 | _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 |
 | _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 |
 
@@ -216,6 +231,7 @@ Settings saved from the UI live in `~/.claude-usage-monitor/config.json`, so you
   "pollIntervalMs": 4000, // how often local logs are re-read
   "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
 }
 ```
 
@@ -254,6 +270,8 @@ Everything lives on your machine, in `~/.claude-usage-monitor/`:
 - `config.json` — your alert settings
 - `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`.
 - `debug.json` — scratch file for the `./pet` simulator
 - `accounts/<id>/` — the same `auth.json` + `alerts.json`, for each extra account
 

package/codex.js

@@ -0,0 +1,220 @@
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+
+// Codex (CLI and the desktop app alike) writes one `rollout-*.jsonl` per
+// session under ~/.codex/sessions/YYYY/MM/DD. Its `token_count` events carry
+// both the token totals and the account's rate limits, so everything here comes
+// from local files — no login needed.
+let codexDir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+
+function setCodexDir(dir) {
+  codexDir = dir || process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+  fileCache.clear()
+}
+
+const DAY = 86400000
+const DAYS = 30
+const WEEK = 7 * DAY
+const ACTIVE_MS = 60000 // a rollout touched within the last minute = Codex working
+const TOP_PROJECTS = 5 // same fold as Claude's panel
+
+// per file: how far we've read, plus what we got out of it. Rollouts only ever
+// grow, so a poll reads just the bytes appended since the last one.
+const fileCache = new Map()
+
+function blankSummary() {
+  return { offset: 0, rest: '', lastTotal: 0, events: [], limits: null, model: null, cwd: null }
+}
+
+// a token_count's rate limits. Codex reports several buckets; some (the
+// `premium` one on Plus, say) come with null windows — only a bucket with a
+// real window is worth showing.
+function limitsOf(rl, ts) {
+  if (!rl || (!rl.primary && !rl.secondary)) return null
+  const win = (w) =>
+    w && typeof w.used_percent === 'number'
+      ? { pct: w.used_percent, resetsAt: w.resets_at ? w.resets_at * 1000 : null }
+      : null
+  return { ts, plan: rl.plan_type || null, primary: win(rl.primary), secondary: win(rl.secondary) }
+}
+
+function ingestLine(sum, line) {
+  // cheap filter before JSON.parse — rollouts are mostly message bodies
+  if (!line.includes('"token_count"') && !line.includes('"turn_context"')) return
+  let o
+  try {
+    o = JSON.parse(line)
+  } catch {
+    return
+  }
+  const p = o.payload || {}
+  const ts = Date.parse(o.timestamp) || 0
+  if (o.type === 'turn_context') {
+    if (p.model) sum.model = p.model
+    if (p.cwd) sum.cwd = p.cwd
+    return
+  }
+  if (p.type !== 'token_count') return
+  // totals are cumulative per session, and the same count is often emitted
+  // twice — the delta is what this event actually spent. The model and project
+  // are the ones in effect *now*, so a mid-session switch is attributed right.
+  const total = p.info?.total_token_usage?.total_tokens
+  if (typeof total === 'number' && total > sum.lastTotal) {
+    sum.events.push({ ts, tokens: total - sum.lastTotal, model: sum.model, cwd: sum.cwd })
+    sum.lastTotal = total
+  }
+  const lim = limitsOf(p.rate_limits, ts)
+  if (lim && (!sum.limits || lim.ts >= sum.limits.ts)) sum.limits = lim
+}
+
+function readFile(file, st) {
+  let sum = fileCache.get(file)
+  // shrunk or replaced: start over
+  if (!sum || st.size < sum.offset) sum = blankSummary()
+  if (st.size > sum.offset) {
+    const fd = fs.openSync(file, 'r')
+    try {
+      const buf = Buffer.alloc(st.size - sum.offset)
+      fs.readSync(fd, buf, 0, buf.length, sum.offset)
+      sum.offset = st.size
+      const lines = (sum.rest + buf.toString('utf8')).split('\n')
+      // the last piece may be a line still being written
+      sum.rest = lines.pop()
+      for (const line of lines) ingestLine(sum, line)
+    } finally {
+      fs.closeSync(fd)
+    }
+  }
+  sum.mtime = st.mtimeMs
+  fileCache.set(file, sum)
+  return sum
+}
+
+// every rollout, with its stat; `since` drops the ones untouched since then
+function rollouts(since) {
+  const out = []
+  const walk = (dir, depth) => {
+    let kids
+    try {
+      kids = fs.readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const k of kids) {
+      const full = path.join(dir, k.name)
+      if (k.isDirectory() && depth < 3) walk(full, depth + 1)
+      else if (k.isFile() && k.name.endsWith('.jsonl')) {
+        try {
+          const st = fs.statSync(full)
+          if (st.mtimeMs >= since) out.push({ file: full, st })
+        } catch {}
+      }
+    }
+  }
+  walk(path.join(codexDir, 'sessions'), 0)
+  return out
+}
+
+// Is there a Codex session on this machine? The folder alone is not enough.
+function detectCodex() {
+  const files = rollouts(0)
+  if (!files.length) return { found: false, plan: null }
+  files.sort((a, b) => b.st.mtimeMs - a.st.mtimeMs)
+  let plan = null
+  for (const { file, st } of files.slice(0, 5)) {
+    const lim = readFile(file, st).limits
+    if (lim?.plan) {
+      plan = lim.plan
+      break
+    }
+  }
+  return { found: true, plan }
+}
+
+// A window whose reset has passed tells us nothing about today: the log is
+// older than the window, so the % is unknown until Codex writes a fresh one.
+function windowNow(w, now) {
+  if (!w) return null
+  const expired = w.resetsAt != null && w.resetsAt <= now
+  return {
+    pct: expired ? null : w.pct,
+    resetMs: w.resetsAt != null && !expired ? w.resetsAt - now : null,
+    expired,
+  }
+}
+
+function ranked(map) {
+  return [...map.entries()]
+    .map(([label, tokens]) => ({ label, tokens }))
+    .sort((a, b) => b.tokens - a.tokens)
+}
+
+function getCodexUsage(now = Date.now()) {
+  if (!fs.existsSync(path.join(codexDir, 'sessions'))) return null
+  const startOfDay = new Date(now).setHours(0, 0, 0, 0)
+  const start30 = startOfDay - (DAYS - 1) * DAY
+  const files = rollouts(start30)
+  const seen = new Set()
+  let limits = null
+  let latest = null
+  let tokensToday = 0
+  let tokens5h = 0
+  let tokensWeek = 0
+  let monthTokens = 0
+  const days30 = new Array(DAYS).fill(0)
+  const byModel = new Map()
+  const byProject = new Map()
+  for (const { file, st } of files) {
+    seen.add(file)
+    const sum = readFile(file, st)
+    if (sum.limits && (!limits || sum.limits.ts > limits.ts)) limits = sum.limits
+    if (!latest || sum.mtime > latest.mtime) latest = sum
+    for (const e of sum.events) {
+      if (e.ts < start30) continue
+      monthTokens += e.tokens
+      days30[Math.min(DAYS - 1, Math.floor((e.ts - start30) / DAY))] += e.tokens
+      if (e.ts >= startOfDay) tokensToday += e.tokens
+      if (now - e.ts < 5 * 3600000) tokens5h += e.tokens
+      if (now - e.ts < WEEK) {
+        tokensWeek += e.tokens
+        const m = e.model || 'unknown'
+        byModel.set(m, (byModel.get(m) || 0) + e.tokens)
+        if (e.cwd) {
+          const p = path.basename(e.cwd)
+          byProject.set(p, (byProject.get(p) || 0) + e.tokens)
+        }
+      }
+    }
+  }
+  // forget files that aged out of the window
+  for (const f of fileCache.keys()) if (!seen.has(f)) fileCache.delete(f)
+
+  const projects = ranked(byProject)
+  const byProjectArr = projects.slice(0, TOP_PROJECTS)
+  const rest = projects.slice(TOP_PROJECTS)
+  if (rest.length) {
+    byProjectArr.push({
+      label: `other · ${rest.length}`,
+      tokens: rest.reduce((n, p) => n + p.tokens, 0),
+    })
+  }
+
+  return {
+    active: !!latest && now - latest.mtime < ACTIVE_MS,
+    lastSeen: latest ? latest.mtime : null,
+    plan: limits?.plan || null,
+    session: limits ? windowNow(limits.primary, now) : null,
+    weekly: limits ? windowNow(limits.secondary, now) : null,
+    limitsAt: limits?.ts || null,
+    tokensToday,
+    tokens5h,
+    tokensWeek,
+    byModel: ranked(byModel),
+    byProject: byProjectArr,
+    days30,
+    monthTokens,
+  }
+}
+
+module.exports = { getCodexUsage, detectCodex, setCodexDir }

package/main.js

@@ -18,8 +18,13 @@ const usage = require('./usage')
 const { getUsage } = usage
 const auth = require('./auth')
 const accounts = require('./accounts')
+const codex = require('./codex')
 
 const REPO = 'renatoaug/claude-usage-monitor'
+const USAGE_URLS = {
+  claude: 'https://claude.ai/settings/usage',
+  codex: 'https://chatgpt.com/usage#settings/Usage',
+}
 
 // data dir: kept outside the project folder so moving the repo doesn't break it.
 // when CLAUDE_CONFIG_DIR is set (e.g. via direnv for multi-account setups), nest
@@ -47,7 +52,7 @@ let win
 let pollTimer
 let config
 let doTick = null
-const W = 276
+const W = 304
 
 // menu-bar (tray) mode state
 let tray = null
@@ -55,6 +60,7 @@ let currentMode = 'floating' // 'floating' widget | 'menubar' popover
 let trayBounds = null // last known tray icon rect, to anchor the popover
 let lastBlurHide = 0 // debounce: ignore the tray click that dismissed the popover
 let sessionPct = null // authoritative session % shown in the tray title
+let codexUsage = null // last Codex payload, null while it isn't enabled
 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
@@ -70,6 +76,7 @@ function publicConfig(c) {
     alertThresholds: c.alertThresholds,
     fireThreshold: c.fireThreshold,
     zoom: c.zoom,
+    codex: !!c.codex?.enabled,
   }
 }
 
@@ -84,6 +91,7 @@ function loadConfig() {
     alertThresholds: [80, 95],
     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
     pollIntervalMs: 4000,
     activeThresholdMs: 20000,
     sleepThresholdMs: 300000,
@@ -188,6 +196,15 @@ function checkAlerts(config, d) {
   ])
   checkWindowReset(config, session.pct)
 }
+// Codex has its own windows, so its own keys: `Codex session:80` never
+// collides with Claude's `Session:80`
+function checkCodexAlerts(config, c) {
+  if (!c) return
+  alertScopes(config, [
+    { label: 'Codex session', pct: c.session?.pct, resetMs: c.session?.resetMs, session: true },
+    { label: 'Codex weekly', pct: c.weekly?.pct, resetMs: c.weekly?.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) {
@@ -408,6 +425,16 @@ function createWindow() {
     } catch (err) {
       win.webContents.send('usage-error', String(err))
     }
+    // Codex is a separate, optional source: its failure must not blank Claude's
+    try {
+      const c = config.codex?.enabled ? codex.getCodexUsage() : null
+      codexUsage = c
+      win.webContents.send('codex', c)
+      checkCodexAlerts(config, c)
+      updateTray()
+    } catch (err) {
+      console.error('codex:', err)
+    }
   }
   doTick = tick
 
@@ -497,10 +524,12 @@ function trayMenu() {
   return Menu.buildFromTemplate([
     { label: 'Open Clauddy', click: () => showPopover() },
     ...accountsMenuItems(),
-    {
-      label: 'Open Usage page',
-      click: () => shell.openExternal('https://claude.ai/settings/usage'),
-    },
+    ...(config.codex?.enabled
+      ? [
+          { label: 'Open Claude usage', click: () => shell.openExternal(USAGE_URLS.claude) },
+          { label: 'Open Codex usage', click: () => shell.openExternal(USAGE_URLS.codex) },
+        ]
+      : [{ label: 'Open Usage page', click: () => shell.openExternal(USAGE_URLS.claude) }]),
     { type: 'separator' },
     { label: 'Quit Clauddy', click: () => app.quit() },
   ])
@@ -595,6 +624,18 @@ function positionFloating() {
 // the tray shows the live session % (macOS title), turning 🔥 near the limit
 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 fmt = (v) => (v == null ? '—' : `${Math.round(v)}%`)
+    const title = sessionPct == null ? `X ${fmt(cxPct)}` : `C ${fmt(sessionPct)} · X ${fmt(cxPct)}`
+    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}`)
+    return
+  }
   if (sessionPct == null) {
     if (process.platform === 'darwin') tray.setTitle('')
     tray.setToolTip('Clauddy — connect your account for live %')
@@ -637,7 +678,20 @@ ipcMain.on('resize', (_e, w, h) => {
   }
 })
 
-ipcMain.on('open-usage', () => shell.openExternal('https://claude.ai/settings/usage'))
+// the arrow opens the page of whichever service the panel is showing
+ipcMain.on('open-usage', (_e, provider) =>
+  shell.openExternal(USAGE_URLS[provider] || USAGE_URLS.claude),
+)
+
+// Settings → Connect Codex: look first; the renderer enables it when found
+ipcMain.on('codex-detect', () => {
+  let r = { found: false, plan: null }
+  try {
+    r = codex.detectCodex()
+  } catch {}
+  if (win && !win.isDestroyed()) win.webContents.send('codex-detected', r)
+})
+ipcMain.on('codex-enable', (_e, on) => setCodexEnabled(!!on))
 
 // watch the debug file; forward forced states to the renderer
 function watchDebug() {
@@ -818,7 +872,17 @@ ipcMain.on('auth-logout', () => {
   profileShown = false
 })
 
-ipcMain.on('save-config', (_e, patch) => {
+// off only stops monitoring here; Codex's own logs and login are untouched
+function setCodexEnabled(on) {
+  writeConfigPatch({ codex: { ...(config.codex || {}), enabled: on } })
+  config = loadConfig()
+  if (!on) codexUsage = null
+  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')]) {
     try {
@@ -831,6 +895,10 @@ ipcMain.on('save-config', (_e, patch) => {
     fs.mkdirSync(path.dirname(EXTERNAL_CONFIG), { recursive: true })
     fs.writeFileSync(EXTERNAL_CONFIG, JSON.stringify(obj, null, 2))
   } catch {}
+}
+
+ipcMain.on('save-config', (_e, patch) => {
+  writeConfigPatch(patch)
   const prevThresholds = String(config.alertThresholds)
   config = loadConfig()
   // re-arm only when the thresholds actually moved: saving an unrelated setting

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clauddy",
   "desktopName": "clauddy.desktop",
-  "version": "1.23.1",
+  "version": "1.24.0",
   "description": "A cute desktop pet that tracks your Claude Code usage",
   "main": "main.js",
   "bin": {
@@ -14,6 +14,7 @@
     "usage.js",
     "auth.js",
     "accounts.js",
+    "codex.js",
     "config.json",
     "renderer"
   ],
@@ -73,6 +74,7 @@
       "usage.js",
       "auth.js",
       "accounts.js",
+      "codex.js",
       "config.json",
       "renderer/**",
       "build/trayTemplate.png",

package/preload.js

@@ -6,7 +6,11 @@ contextBridge.exposeInMainWorld('api', {
   onConfig: (cb) => ipcRenderer.on('config', (_e, cfg) => cb(cfg)),
   saveConfig: (patch) => ipcRenderer.send('save-config', patch),
   resize: (w, h) => ipcRenderer.send('resize', w, h),
-  openUsage: () => ipcRenderer.send('open-usage'),
+  openUsage: (provider) => ipcRenderer.send('open-usage', provider),
+  codexDetect: () => ipcRenderer.send('codex-detect'),
+  onCodexDetected: (cb) => ipcRenderer.on('codex-detected', (_e, r) => cb(r)),
+  codexEnable: (on) => ipcRenderer.send('codex-enable', on),
+  onCodex: (cb) => ipcRenderer.on('codex', (_e, c) => cb(c)),
   onRealUsage: (cb) => ipcRenderer.on('real-usage', (_e, u) => cb(u)),
   onAuthState: (cb) => ipcRenderer.on('auth-state', (_e, s) => cb(s)),
   onProfile: (cb) => ipcRenderer.on('profile', (_e, p) => cb(p)),