clauddy 1.29.0 → 2.0.0

package/package.json

@@ -1,38 +1,18 @@
 {
   "name": "clauddy",
-  "desktopName": "clauddy.desktop",
-  "version": "1.29.0",
-  "description": "A cute desktop pet that tracks your Claude Code usage",
-  "main": "main.js",
+  "version": "2.0.0",
+  "description": "A desktop pet that tracks your Claude Code usage",
   "bin": {
     "clauddy": "bin/clauddy.js"
   },
   "files": [
-    "bin",
-    "main.js",
-    "preload.js",
-    "usage.js",
-    "auth.js",
-    "accounts.js",
-    "codex.js",
-    "cursor.js",
-    "reminders.js",
-    "config.json",
-    "renderer"
+    "bin"
   ],
   "scripts": {
-    "start": "electron .",
-    "pack": "node scripts/build-app.js --dir",
-    "dist": "node scripts/build-app.js --mac zip --publish never",
-    "dist:win": "node scripts/build-app.js --win zip --publish never",
-    "dist:linux": "node scripts/build-app.js --linux --publish never",
-    "icon": "bash build-icon.sh",
-    "gifs": "electron tools/capture/capture.js",
-    "test": "bun test test/unit/ && bun test test/main/ && bun test test/dom/",
-    "test:coverage": "node scripts/check-coverage.js",
-    "format": "biome format --write .",
-    "lint": "biome lint .",
+    "test": "bun test test/",
     "check": "biome check --write .",
+    "lint": "biome lint .",
+    "format": "biome format --write .",
     "prepare": "git config core.hooksPath .githooks || true"
   },
   "author": "Renato",
@@ -51,7 +31,6 @@
     "usage",
     "monitor",
     "desktop-pet",
-    "electron",
     "macos",
     "menubar",
     "widget"
@@ -61,62 +40,11 @@
   },
   "packageManager": "bun@1.3.14",
   "engines": {
-    "node": ">=24"
-  },
-  "build": {
-    "appId": "app.clauddy",
-    "afterPack": "scripts/adhoc-sign.js",
-    "productName": "Clauddy",
-    "directories": {
-      "output": "dist"
-    },
-    "files": [
-      "main.js",
-      "preload.js",
-      "usage.js",
-      "auth.js",
-      "accounts.js",
-      "codex.js",
-      "cursor.js",
-      "reminders.js",
-      "config.json",
-      "renderer/**",
-      "build/trayTemplate.png",
-      "build/trayTemplate@2x.png",
-      "build/trayColor.png",
-      "build/trayColor@2x.png",
-      "build/icon.png"
-    ],
-    "mac": {
-      "category": "public.app-category.developer-tools",
-      "target": "dir",
-      "identity": null,
-      "icon": "build/icon.icns",
-      "artifactName": "${productName}-${version}-mac-${arch}.${ext}"
-    },
-    "win": {
-      "target": "zip",
-      "icon": "build/icon.ico",
-      "artifactName": "${productName}-${version}-win-${arch}.${ext}"
-    },
-    "linux": {
-      "target": [
-        "tar.gz",
-        "AppImage"
-      ],
-      "artifactName": "${productName}-${version}-linux-${arch}.${ext}",
-      "category": "Utility",
-      "icon": "build/icon.png",
-      "syncDesktopName": true
-    }
-  },
-  "dependencies": {
-    "electron": "^42.4.1"
+    "node": ">=18"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.5.0",
-    "@happy-dom/global-registrator": "^20.11.2",
-    "electron-builder": "^26.15.3",
-    "semantic-release": "^25.0.5"
+    "@biomejs/biome": "^2.6.6",
+    "conventional-changelog-conventionalcommits": "^9.3.1",
+    "semantic-release": "^25.0.9"
   }
 }

package/accounts.js

@@ -1,181 +0,0 @@
-// Multiple Claude subscriptions in one widget.
-//
-// An account is a token plus, optionally, the Claude config dir whose logs it
-// reads. The first one ("default") keeps the paths the app has always used, so
-// an existing install carries over untouched; every extra account gets its own
-// folder under `accounts/` for auth.json and alerts.json.
-//
-// Only the active account is polled — and therefore only it can notify.
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
-
-const BASE_DIR = process.env.CLAUDE_CONFIG_DIR
-  ? path.join(process.env.CLAUDE_CONFIG_DIR, 'usage-monitor')
-  : path.join(os.homedir(), '.claude-usage-monitor')
-const FILE = path.join(BASE_DIR, 'accounts.json')
-const DEFAULT_ID = 'default'
-
-function defaults() {
-  return { active: DEFAULT_ID, accounts: [{ id: DEFAULT_ID, label: null, claudeDir: null }] }
-}
-
-function sane(j) {
-  const list = (Array.isArray(j?.accounts) ? j.accounts : [])
-    .filter((a) => a && typeof a.id === 'string' && a.id)
-    .map((a) => ({
-      id: a.id,
-      label: typeof a.label === 'string' && a.label ? a.label : null,
-      claudeDir: typeof a.claudeDir === 'string' && a.claudeDir ? a.claudeDir : null,
-    }))
-  // the default account can be removed like any other, so it is only recreated
-  // when nothing is left — an empty list would leave the widget with no token
-  if (!list.length) list.push(defaults().accounts[0])
-  const active = list.some((a) => a.id === j?.active) ? j.active : list[0].id
-  return { active, accounts: list }
-}
-
-// re-read on every call instead of caching: the file is a handful of rows, it
-// is read only when the account list is shown or changed, and a stale cache
-// here would mean the widget polling a token it thinks it still has
-function load() {
-  try {
-    return sane(JSON.parse(fs.readFileSync(FILE, 'utf8')))
-  } catch {
-    return defaults() // first run, or a corrupted file
-  }
-}
-
-function save(state) {
-  try {
-    fs.mkdirSync(BASE_DIR, { recursive: true })
-    fs.writeFileSync(FILE, JSON.stringify(state, null, 2))
-  } catch {}
-}
-
-// where an account's own files (auth.json, alerts.json) live
-function dataDirOf(id) {
-  return id === DEFAULT_ID ? BASE_DIR : path.join(BASE_DIR, 'accounts', id)
-}
-
-function list() {
-  return load().accounts.map((a) => ({ ...a }))
-}
-
-function activeId() {
-  return load().active
-}
-
-function active() {
-  const s = load()
-  return s.accounts.find((a) => a.id === s.active) || s.accounts[0]
-}
-
-function find(s, id) {
-  return s.accounts.find((a) => a.id === id)
-}
-
-function setActive(id) {
-  const s = load()
-  const hit = find(s, id)
-  if (!hit) return null
-  s.active = id
-  save(s)
-  return hit
-}
-
-// a fresh, logged-out account — the caller switches to it and runs the usual
-// browser login, which is what gives it an identity
-function add(claudeDir) {
-  const s = load()
-  // two clicks inside the same millisecond used to mint the same id, and the
-  // duplicate then looked like the account we were already on
-  let id = `acct-${Date.now().toString(36)}`
-  while (s.accounts.some((a) => a.id === id)) {
-    id = `acct-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`
-  }
-  s.accounts.push({ id, label: null, claudeDir: claudeDir || null })
-  save(s)
-  return id
-}
-
-// the login flow knows the email; that's a better name than "Account 2"
-function label(id, text) {
-  const s = load()
-  const a = find(s, id)
-  if (!a || a.label === (text || null)) return
-  a.label = text || null
-  save(s)
-}
-
-function setClaudeDir(id, dir) {
-  const s = load()
-  const a = find(s, id)
-  if (!a) return
-  a.claudeDir = dir || null
-  save(s)
-}
-
-// removing an account takes its token with it — leaving a stray auth.json
-// behind would be a credential nobody can see or revoke from the UI
-function remove(id) {
-  const s = load()
-  if (id === s.active) return false // switch away first: the widget is showing it
-  const i = s.accounts.findIndex((a) => a.id === id)
-  if (i < 0) return false
-  if (s.accounts.length < 2) return false // never leave the widget with no account
-  s.accounts.splice(i, 1)
-  save(s)
-  try {
-    if (id === DEFAULT_ID) {
-      // its folder is the app's own data dir: drop the credentials, not the
-      // settings, the account list or the simulator file that live beside them
-      for (const f of ['auth.json', 'alerts.json'])
-        fs.rmSync(path.join(dataDirOf(id), f), { force: true })
-    } else {
-      fs.rmSync(dataDirOf(id), { recursive: true, force: true })
-    }
-  } catch {}
-  return true
-}
-
-// Folders left behind under `accounts/` by slots that are no longer listed —
-// an add abandoned mid-login, mostly, since saving the alert state recreates
-// the folder on its way out. Only ever drops a folder with no auth.json in it,
-// so a token is never destroyed by a bad read of accounts.json.
-function pruneOrphans() {
-  const root = path.join(BASE_DIR, 'accounts')
-  let dirs = []
-  try {
-    dirs = fs.readdirSync(root, { withFileTypes: true })
-  } catch {
-    return 0 // no extra accounts were ever added
-  }
-  const known = new Set(list().map((a) => a.id))
-  let n = 0
-  for (const d of dirs) {
-    if (!d.isDirectory() || known.has(d.name)) continue
-    const dir = path.join(root, d.name)
-    if (fs.existsSync(path.join(dir, 'auth.json'))) continue
-    try {
-      fs.rmSync(dir, { recursive: true, force: true })
-      n++
-    } catch {}
-  }
-  return n
-}
-
-module.exports = {
-  BASE_DIR,
-  DEFAULT_ID,
-  dataDirOf,
-  list,
-  active,
-  activeId,
-  setActive,
-  add,
-  label,
-  setClaudeDir,
-  remove,
-  pruneOrphans,
-}

package/auth.js

@@ -1,300 +0,0 @@
-// Claude OAuth (same flow as Claude Code) + the authoritative usage endpoint.
-const crypto = require('node:crypto')
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
-
-const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e'
-const REDIRECT = 'https://platform.claude.com/oauth/code/callback'
-const AUTHORIZE = 'https://claude.ai/oauth/authorize'
-const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token'
-const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
-const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile'
-const SCOPE = 'org:create_api_key user:profile user:inference'
-const UA = 'claude-cli/2.1.181 (external, cli)'
-// when CLAUDE_CONFIG_DIR is set (e.g. via direnv for multi-account setups),
-// keep the widget's data alongside that account's Claude config
-const DATA_DIR = process.env.CLAUDE_CONFIG_DIR
-  ? path.join(process.env.CLAUDE_CONFIG_DIR, 'usage-monitor')
-  : path.join(os.homedir(), '.claude-usage-monitor')
-// mutable: with several accounts configured, each one keeps its token in its
-// own dir and the widget switches between them at runtime
-let tokenPath = path.join(DATA_DIR, 'auth.json')
-
-const b64url = (buf) =>
-  buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-
-let tokens = null // { access_token, refresh_token, expires_at }
-let pending = null // { verifier, state }
-let profile = null // { email, name, plan } — cached account identity
-
-// point the module at another account's dir — the cached token and profile
-// belong to the previous one, so both are dropped
-function setDataDir(dir) {
-  tokenPath = path.join(dir || DATA_DIR, 'auth.json')
-  tokens = null
-  profile = null
-  pending = null
-  unreadable = false
-}
-
-// Set when the file itself could not be read for a reason other than "it is not
-// there" — a disk still waking up, say. That must not read as a logout, or the
-// widget asks for a login it doesn't need and every account looks gone. A file
-// we did read but cannot parse is a different matter: that one really is dead.
-let unreadable = false
-function load() {
-  if (tokens) return tokens
-  let raw = null
-  try {
-    raw = fs.readFileSync(tokenPath, 'utf8')
-    unreadable = false
-  } catch (e) {
-    unreadable = e?.code !== 'ENOENT'
-  }
-  try {
-    tokens = raw == null ? null : JSON.parse(raw)
-  } catch {
-    tokens = null
-  }
-  return tokens
-}
-function save(t) {
-  tokens = t
-  try {
-    fs.mkdirSync(path.dirname(tokenPath), { recursive: true })
-    fs.writeFileSync(tokenPath, JSON.stringify(t, null, 2), { mode: 0o600 })
-  } catch {}
-}
-function clear() {
-  tokens = null
-  profile = null
-  unreadable = false
-  try {
-    fs.unlinkSync(tokenPath)
-  } catch {}
-}
-function isConnected() {
-  // a token we merely failed to read still counts: the account is connected,
-  // we just couldn't see it this instant
-  return !!load() || unreadable
-}
-
-// Step 1: build the authorize URL (opens in the browser)
-function begin() {
-  const verifier = b64url(crypto.randomBytes(32))
-  const challenge = b64url(crypto.createHash('sha256').update(verifier).digest())
-  const state = b64url(crypto.randomBytes(32))
-  pending = { verifier, state }
-  const params = {
-    code: 'true',
-    client_id: CLIENT_ID,
-    response_type: 'code',
-    redirect_uri: REDIRECT,
-    scope: SCOPE,
-    code_challenge: challenge,
-    code_challenge_method: 'S256',
-    state,
-  }
-  const query = Object.entries(params)
-    .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
-    .join('&')
-  return `${AUTHORIZE}?${query}`
-}
-
-// Step 2: exchange the pasted "code#state" for tokens
-async function complete(pasted) {
-  const raw = String(pasted).trim()
-  // A directly-pasted long-lived token (e.g. from `claude setup-token`) skips
-  // the rate-limited code exchange entirely.
-  if (!raw.includes('#')) {
-    save({ access_token: raw, refresh_token: null, expires_at: Date.now() + 365 * 864e5 })
-    pending = null
-    return
-  }
-  if (!pending) throw new Error('no pending auth')
-  const [code, returnedState] = raw.split('#')
-  const res = await fetch(TOKEN_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'User-Agent': UA },
-    body: JSON.stringify({
-      grant_type: 'authorization_code',
-      code,
-      state: returnedState || pending.state,
-      code_verifier: pending.verifier,
-      client_id: CLIENT_ID,
-      redirect_uri: REDIRECT,
-    }),
-  })
-  if (!res.ok) {
-    const body = await res.text().catch(() => '')
-    throw new Error(`exchange ${res.status}: ${body.slice(0, 150)}`)
-  }
-  const j = await res.json()
-  save({
-    access_token: j.access_token,
-    refresh_token: j.refresh_token,
-    expires_at: Date.now() + (j.expires_in || 3600) * 1000,
-  })
-  pending = null
-}
-
-// Usage and profile both ask for a valid token at once. Two refreshes would
-// rotate the refresh token twice, and the loser's grant comes back rejected —
-// so callers share the one in flight.
-let refreshing = null
-function refresh() {
-  if (!refreshing) refreshing = doRefresh().finally(() => (refreshing = null))
-  return refreshing
-}
-async function doRefresh() {
-  const t = load()
-  if (!t?.refresh_token) throw Object.assign(new Error('no refresh token'), { status: 401 })
-  const res = await fetch(TOKEN_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'User-Agent': UA },
-    body: JSON.stringify({
-      grant_type: 'refresh_token',
-      refresh_token: t.refresh_token,
-      client_id: CLIENT_ID,
-    }),
-  })
-  if (!res.ok) {
-    // a rejected grant (expired/revoked refresh token) means the session is
-    // dead — surface it as 401 so callers clear the token and prompt login.
-    // transient failures (429, 5xx) keep their status so we retry, not logout.
-    const dead = res.status === 400 || res.status === 403
-    throw Object.assign(new Error('refresh failed'), { status: dead ? 401 : res.status })
-  }
-  const j = await res.json()
-  save({
-    access_token: j.access_token,
-    refresh_token: j.refresh_token || t.refresh_token,
-    expires_at: Date.now() + (j.expires_in || 3600) * 1000,
-  })
-}
-
-async function validToken() {
-  const t = load()
-  // status 0 is "try again later", not "log in again": only a token that is
-  // genuinely absent should send the user back through the browser
-  if (!t) {
-    throw Object.assign(new Error(unreadable ? 'token unreadable' : 'not connected'), {
-      status: unreadable ? 0 : 401,
-    })
-  }
-  if (!t.expires_at || t.expires_at - Date.now() < 60000) await refresh()
-  return load().access_token
-}
-
-function win(o) {
-  return o && typeof o.utilization === 'number'
-    ? { pct: o.utilization, resetMs: o.resets_at ? Date.parse(o.resets_at) - Date.now() : null }
-    : null
-}
-
-// Weekly limits scoped to one model (e.g. "Fable" on Max) live in the `limits`
-// array. The older seven_day_<model> windows are kept as a fallback for plans
-// that still report them that way.
-function scopedWeeks(j) {
-  const out = []
-  for (const l of Array.isArray(j.limits) ? j.limits : []) {
-    if (l?.kind !== 'weekly_scoped' || typeof l.percent !== 'number') continue
-    const label = l.scope?.model?.display_name
-    if (!label) continue
-    out.push({
-      label,
-      pct: l.percent,
-      resetMs: l.resets_at ? Date.parse(l.resets_at) - Date.now() : null,
-    })
-  }
-  if (out.length) return out
-  for (const [key, label] of [
-    ['seven_day_opus', 'Opus'],
-    ['seven_day_sonnet', 'Sonnet'],
-  ]) {
-    const w = win(j[key])
-    if (w) out.push({ label, ...w })
-  }
-  return out
-}
-
-// What the endpoint says its own budget is. Undocumented, so we only ever read
-// it — nothing depends on it yet. Knowing the real numbers is what tells us how
-// close the activity poll's floor can get.
-let rateLimit = null
-function readRateLimit(res) {
-  const out = {}
-  try {
-    for (const [k, v] of res.headers) {
-      if (k.startsWith('anthropic-ratelimit-')) out[k.slice(20)] = v
-    }
-  } catch {
-    return // no headers to read — nothing here is worth failing a fetch over
-  }
-  if (!Object.keys(out).length) return
-  if (JSON.stringify(out) !== JSON.stringify(rateLimit)) console.log('usage rate limit', out)
-  rateLimit = out
-}
-
-// Step 3: fetch the authoritative usage
-async function fetchUsage() {
-  const token = await validToken()
-  const res = await fetch(USAGE_URL, {
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'anthropic-beta': 'oauth-2025-04-20',
-      'anthropic-version': '2023-06-01',
-      'User-Agent': UA,
-    },
-  })
-  if (!res.ok) {
-    const body = await res.text().catch(() => '')
-    throw Object.assign(new Error(`usage ${res.status}: ${body.slice(0, 150)}`), {
-      status: res.status,
-    })
-  }
-  readRateLimit(res)
-  const j = await res.json()
-  return {
-    session: win(j.five_hour) || { pct: 0, resetMs: null },
-    week: win(j.seven_day) || { pct: 0, resetMs: null },
-    scoped: scopedWeeks(j),
-  }
-}
-
-// The logged-in account's identity (email + plan tier). Cached for the session;
-// only changes on logout/login, so we don't re-fetch on every usage poll.
-async function fetchProfile() {
-  if (profile) return profile
-  const token = await validToken()
-  const res = await fetch(PROFILE_URL, {
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'anthropic-beta': 'oauth-2025-04-20',
-      'anthropic-version': '2023-06-01',
-      'User-Agent': UA,
-    },
-  })
-  if (!res.ok) {
-    throw Object.assign(new Error(`profile ${res.status}`), { status: res.status })
-  }
-  const a = (await res.json()).account || {}
-  profile = {
-    email: a.email || null,
-    name: a.display_name || a.full_name || null,
-    plan: a.has_claude_max ? 'Max' : a.has_claude_pro ? 'Pro' : null,
-  }
-  return profile
-}
-
-module.exports = {
-  rateLimit: () => rateLimit,
-  begin,
-  complete,
-  fetchUsage,
-  fetchProfile,
-  clear,
-  isConnected,
-  setDataDir,
-}