clauddy 1.23.1 → 1.25.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:
@@ -95,6 +109,35 @@ Other activities — **planning**, **researching**, **delegating**, **waiting**
 show up in the status line as they happen. When Claude goes quiet, the pet drops
 back to plain **working** / **idle**.
 
+## The pet talks
+
+Now and then the pet says something in a speech bubble. It only speaks when something changes, never on a timer, and it keeps quiet when it has nothing specific to say. Remarks are at least 10 minutes apart; the big moments can cut that line.
+
+| Moment | What it says (expanded) | Minimized | Blip |
+| --- | --- | --- | --- |
+| First launch of the day | _Good morning! Yesterday was your heaviest day this week, 12M tokens._ | _Morning! Big day yesterday._ | ✓ |
+| Session crosses your fire threshold | _Getting warm, 91% already. At this pace you'll run out in about 40m._ | _91%, getting warm!_ | ✓ |
+| The session window resets | _Fresh window! That was 34M tokens over 4h 12m, mostly editing code._ | _Fresh window! 34M last time._ | ✓ |
+| The session hits 100% | _That's the limit. I'll be back at 2:35 PM._ | _Maxed out till 2:35 PM._ | |
+| You're back after 2+ hours away | _Welcome back! You were gone 3h 12m. The session's at 12%._ | _Welcome back!_ | |
+| 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) |
+
+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.
+
+### The voice
+
+Optionally the pet also **blips** as it talks: short chiptune notes, one per letter, generated live with Web Audio (square waves, no sound files). It blips faster and higher when it's on fire, slower and lower when it's sleepy. Only the headline moments blip (the ✓ rows above), because a sound on every remark wears out fast.
+
+Audio should never catch you off guard in a meeting:
+
+- **Off by default.** Turn it on under **⚙ Settings → voice → Chiptune voice** (you'll hear a sample).
+- **One-click mute.** While the voice is on, a 🔊 button sits in the title bar. Click it to mute for an hour, and again to unmute.
+- **Always silent** in menu-bar mode and while the pet is minimized.
+
+**Speech bubbles** can be switched off entirely in the same place. Try any remark from the terminal with `bunx clauddy say <kind>` ([see below](#play-with-the-pet)).
+
 ## Install
 
 **macOS (Apple Silicon)** is the first-class build. **Windows (x64)** and **Linux (x64)** work too. The `bunx`/`npx` route below runs on all of them today.
@@ -171,17 +214,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 +237,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 +260,10 @@ 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
+  "talk": true, // speech bubbles on transitions
+  "sound": false, // chiptune blips, opt-in
+  "soundMutedUntil": 0, // set by the 🔊 button: muted until this epoch ms
 }
 ```
 
@@ -232,6 +280,8 @@ bunx clauddy working     # 🍴 eats token coins
 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
 ```
 
 Each state is written to the data dir the running widget watches, so it reacts
@@ -243,7 +293,7 @@ live. (Installed globally? Drop the `bunx`: `clauddy poke`. Working on the repo?
 - **`main.js`** — Electron main process: frameless, transparent, always-on-top window; polls usage; fires macOS notifications; watches `config.json` and `debug.json`.
 - **`usage.js`** — reads `~/.claude/projects/**/*.jsonl`, sums tokens per model/project/day, detects the rolling 5-hour session window, the working/sleeping status, and which activity (reading/editing/running/…) Claude is on from its latest tool use.
 - **`auth.js`** — OAuth login (PKCE, same public client as Claude Code) that fetches the authoritative usage %. Token stored locally, never committed.
-- **`renderer/`** — the pet itself: an SVG pixel sprite, CSS animations, and the Web Animations API for particles.
+- **`renderer/`** — the pet itself: an SVG pixel sprite, CSS animations, and the Web Animations API for particles. `voice.js` writes its remarks and synthesizes the blips.
 - **`make-icon.js`** — generates the app icon from the pixel sprite (`build/icon.icns`).
 
 ## Data & privacy
@@ -254,6 +304,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/bin/clauddy.js

@@ -20,6 +20,7 @@ const STATES = [
   'idle',
   'poke',
   'celebrate',
+  'say',
   'auto',
   'clear',
   // activity states (what Claude Code is doing)
@@ -31,7 +32,10 @@ const STATES = [
   'delegating',
   'waiting',
 ]
+// `clauddy say <kind>` previews one of the pet's remarks
+const REMARKS = ['greeting', 'fire', 'reset', 'maxed', 'welcome', 'streak', 'record', 'codex']
 const arg = process.argv[2]
+const kind = arg === 'say' ? process.argv[3] || 'greeting' : undefined
 
 if (!arg) {
   // no argument → launch the app
@@ -47,19 +51,25 @@ if (!arg) {
       'Usage:',
       '  clauddy            launch the widget',
       '  clauddy <state>    poke the running widget (just for fun)',
+      '  clauddy say [kind] make the pet say one of its remarks',
       '',
       'States: fire, sleeping, working, tired, idle, poke, celebrate, auto',
+      `Remarks: ${REMARKS.join(', ')}`,
       '(the widget must be running for a state to show)',
     ].join('\n'),
   )
+} else if (kind && !REMARKS.includes(kind)) {
+  console.error(`clauddy: unknown remark "${kind}"`)
+  console.error(`try: ${REMARKS.join(', ')}`)
+  process.exit(1)
 } else if (STATES.includes(arg)) {
   // write the state for the running app to pick up
   fs.mkdirSync(dataDir, { recursive: true })
   fs.writeFileSync(
     path.join(dataDir, 'debug.json'),
-    `${JSON.stringify({ state: arg, t: Date.now() })}\n`,
+    `${JSON.stringify({ state: arg, kind, t: Date.now() })}\n`,
   )
-  console.log(`clauddy → ${arg} (the running widget will react)`)
+  console.log(`clauddy → ${arg}${kind ? ` ${kind}` : ''} (the running widget will react)`)
 } else {
   console.error(`clauddy: unknown command "${arg}"`)
   console.error('try: fire, sleeping, working, tired, idle, poke, celebrate, auto — or --help')

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,10 @@ function publicConfig(c) {
     alertThresholds: c.alertThresholds,
     fireThreshold: c.fireThreshold,
     zoom: c.zoom,
+    codex: !!c.codex?.enabled,
+    talk: c.talk,
+    sound: c.sound,
+    soundMutedUntil: c.soundMutedUntil,
   }
 }
 
@@ -84,6 +94,10 @@ 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
+    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
     pollIntervalMs: 4000,
     activeThresholdMs: 20000,
     sleepThresholdMs: 300000,
@@ -188,6 +202,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) {
@@ -362,6 +385,9 @@ function createWindow() {
       preload: path.join(__dirname, 'preload.js'),
       contextIsolation: true,
       nodeIntegration: false,
+      // the pet's blips start from a usage change, never from a click, so
+      // Chromium would otherwise hold the AudioContext suspended
+      autoplayPolicy: 'no-user-gesture-required',
     },
   })
 
@@ -408,6 +434,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 +533,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 +633,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 +687,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 +881,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 +904,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.25.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)),