clauddy 1.29.1 → 2.0.1

package/README.md

@@ -1,6 +1,6 @@
 # 🟫 Clauddy
 
-A pixel-art desktop pet that keeps an eye on your Claude Code usage: the real session and weekly % from your account, the tokens from your local logs, and a pet that works, sleeps and catches fire along with it. It can follow Codex and Cursor too, and you can dress it as a pumpkin, a ghost or Santa.
+A pixel-art desktop pet that keeps an eye on your Claude Code usage: the real session and weekly % from your account, the tokens from your local logs, and a pet that works, sleeps and catches fire along with it. It can follow Codex and Cursor too, and you can dress it as a wizard, Santa or a gingerbread cookie.
 
 <p align="center">
   <a href="#running">📚 Get started</a> ·
@@ -14,7 +14,7 @@ https://github.com/user-attachments/assets/be8d339c-ac69-4980-96a7-8e286f8b080f
 
 ## Stack
 
-An Electron widget in vanilla JS, with Bun for the scripts and the tests, and Biome for format and lint.
+A native app in Rust with egui, no browser engine: about 1–2% CPU and a 20 MB app. The `clauddy` command on npm is a small launcher that downloads it.
 
 More details, with every tool and version, in [`docs/design/01-architecture.md`](docs/design/01-architecture.md#stack).
 
@@ -22,7 +22,8 @@ More details, with every tool and version, in [`docs/design/01-architecture.md`]
 
 - macOS on Apple Silicon (the first-class build), Windows x64 or Linux x64
 - [Claude Code](https://claude.com/claude-code), whose logs in `~/.claude/projects` give the token counts; a Claude login, done once in Settings, gives the real %
-- [Bun](https://bun.sh), or Node 24 for `npx`, only to run it without installing or to work on the code
+- [Bun](https://bun.sh), or Node 18+ for `npx`, only to run it with `bunx clauddy`
+- [Rust](https://rustup.rs), only to work on the code
 - Optional: [Codex](https://openai.com/codex) or the [Cursor](https://cursor.com) app on the same machine, to follow them too
 
 ## Running
@@ -44,14 +45,15 @@ bunx clauddy
 ## Test
 
 ```bash
-bun run check            # Biome format and lint (autofix)
-bun run test             # the three test groups, each in its own process
-bun run test:coverage    # the same, failing under 80% overall or 60% per file
-bun run pack             # builds dist/mac-arm64/Clauddy.app
-./pet fire               # forces a pet state in the running widget (./pet auto to go back)
+cd native
+cargo fmt --check                  # formatting
+cargo clippy --release --all-targets -- -D warnings   # lint
+cargo test --release               # unit tests and the snapshot gallery
+scripts/bundle.sh                  # builds target/Clauddy.app (macOS)
+CLAUDDY_STATE=fire cargo run --release   # forces a mood: idle, working, fire, tired, sleeping
 ```
 
-Never run bare `bun test`: the groups under `test/` must each run in their own process ([ADR-002](docs/decisions/ADR-002-three-test-processes.md)). `bun install` turns on a pre-commit hook that formats the staged files and blocks on lint errors. CI runs the coverage gate on every pull request.
+The snapshot gallery renders every screen state into `native/tests/snapshots/`; after an intended visual change, `UPDATE_SNAPSHOTS=1 cargo test --release` rewrites it. At the root, `bun run test` tests the npm launcher, and `bun install` turns on a pre-commit hook that formats it. CI runs all of it on every pull request.
 
 ## Releases
 

package/bin/clauddy.js

@@ -1,87 +1,90 @@
 #!/usr/bin/env node
 
-// `clauddy`            → launch the widget (spawns Electron on main.js)
-// `clauddy <state>`    → poke the running widget for fun/demo (writes the state
-//                        to the data dir the app watches; the app reacts live)
-const path = require('node:path')
+// `clauddy` launches the native app (native/, Rust). The first run of each
+// version downloads that version's release build for this OS into
+// ~/.claude-usage-monitor/bin/<version>/; later runs open it straight away.
+// The app runs on its own: this launcher exits as soon as it has started it.
 const fs = require('node:fs')
 const os = require('node:os')
+const path = require('node:path')
+const { spawn, execFileSync } = require('node:child_process')
+
+const REPO = 'renatoaug/claude-usage-monitor'
+
+// the release asset for an OS, and the file inside it to start
+function assetFor(platform, arch, version) {
+  if (platform === 'darwin' && arch === 'arm64')
+    return { file: `Clauddy-${version}-arm64-mac.zip`, app: 'Clauddy.app' }
+  if (platform === 'win32' && arch === 'x64')
+    return { file: `Clauddy-${version}-win-x64.zip`, app: 'Clauddy.exe' }
+  if (platform === 'linux' && arch === 'x64')
+    return { file: `Clauddy-${version}-linux-x64.tar.gz`, app: path.join('Clauddy', 'clauddy') }
+  return undefined
+}
+
+function dataDir() {
+  return process.env.CLAUDE_CONFIG_DIR
+    ? path.join(process.env.CLAUDE_CONFIG_DIR, 'usage-monitor')
+    : path.join(os.homedir(), '.claude-usage-monitor')
+}
+
+async function install(asset, version, dir) {
+  const url = `https://github.com/${REPO}/releases/download/v${version}/${asset.file}`
+  console.log(`clauddy: downloading ${asset.file}…`)
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`download failed (${res.status}): ${url}`)
+  const tmp = `${dir}.tmp`
+  fs.rmSync(tmp, { recursive: true, force: true })
+  fs.mkdirSync(tmp, { recursive: true })
+  const archive = path.join(tmp, asset.file)
+  fs.writeFileSync(archive, Buffer.from(await res.arrayBuffer()))
+  // ditto keeps the app bundle's signature; tar reads zips on Windows 10+
+  if (process.platform === 'darwin') execFileSync('ditto', ['-x', '-k', archive, tmp])
+  else execFileSync('tar', ['-xf', archive, '-C', tmp])
+  fs.rmSync(archive)
+  fs.rmSync(dir, { recursive: true, force: true })
+  fs.renameSync(tmp, dir)
+}
 
-// same data dir the app uses (respects CLAUDE_CONFIG_DIR for multi-account)
-const dataDir = process.env.CLAUDE_CONFIG_DIR
-  ? path.join(process.env.CLAUDE_CONFIG_DIR, 'usage-monitor')
-  : path.join(os.homedir(), '.claude-usage-monitor')
+// older versions' builds are dead weight once a newer one is in
+function prune(root, keep) {
+  for (const name of fs.readdirSync(root)) {
+    if (name !== keep) fs.rmSync(path.join(root, name), { recursive: true, force: true })
+  }
+}
 
-const STATES = [
-  'fire',
-  'sleeping',
-  'working',
-  'tired',
-  'idle',
-  'poke',
-  'celebrate',
-  'say',
-  'auto',
-  'clear',
-  // activity states (what Claude Code is doing)
-  'editing',
-  'reading',
-  'planning',
-  'running',
-  'researching',
-  'delegating',
-  'waiting',
-]
-// `clauddy say <kind>` previews one of the pet's remarks
-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
+async function main() {
+  const arg = process.argv[2]
+  if (arg === '--help' || arg === '-h') {
+    console.log(
+      'clauddy — a desktop pet that tracks your Claude Code usage\n\nUsage:\n  clauddy    launch the app',
+    )
+    return
+  }
+  const { version } = require('../package.json')
+  const asset = assetFor(process.platform, process.arch, version)
+  if (!asset) {
+    console.error(
+      `clauddy: no build for ${process.platform}-${process.arch} (macOS arm64, Windows x64, Linux x64)`,
+    )
+    process.exit(1)
+  }
+  const root = path.join(dataDir(), 'bin')
+  const dir = path.join(root, version)
+  const app = path.join(dir, asset.app)
+  if (!fs.existsSync(app)) {
+    await install(asset, version, dir)
+    prune(root, version)
+  }
+  const [cmd, args] = process.platform === 'darwin' ? ['open', [app]] : [app, []]
+  spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref()
+}
 
-if (!arg) {
-  // no argument → launch the app
-  const { spawn } = require('node:child_process')
-  const electron = require('electron')
-  const child = spawn(electron, [path.join(__dirname, '..', 'main.js')], { stdio: 'inherit' })
-  child.on('close', (code) => process.exit(code ?? 0))
-} else if (arg === '--help' || arg === '-h') {
-  console.log(
-    [
-      'clauddy — a cute desktop pet that tracks your Claude Code usage',
-      '',
-      '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, kind, t: Date.now() })}\n`,
-  )
-  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')
-  process.exit(1)
+if (require.main === module) {
+  main().catch((e) => {
+    console.error(`clauddy: ${e.message}`)
+    process.exit(1)
+  })
 }
+
+module.exports = { assetFor }

package/package.json

@@ -1,38 +1,18 @@
 {
   "name": "clauddy",
-  "desktopName": "clauddy.desktop",
-  "version": "1.29.1",
-  "description": "A cute desktop pet that tracks your Claude Code usage",
-  "main": "main.js",
+  "version": "2.0.1",
+  "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,
-}