clauddy 1.29.0 → 2.0.0

package/main.js

@@ -1,1305 +0,0 @@
-const {
-  app,
-  BrowserWindow,
-  ipcMain,
-  screen,
-  Notification,
-  shell,
-  Tray,
-  Menu,
-  nativeImage,
-  powerMonitor,
-} = require('electron')
-const path = require('node:path')
-const fs = require('node:fs')
-const os = require('node:os')
-const { spawn } = require('node:child_process')
-const usage = require('./usage')
-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.
-// when CLAUDE_CONFIG_DIR is set (e.g. via direnv for multi-account setups), nest
-// the widget's data under that account's Claude config dir so each account gets
-// its own auth.json, config.json, and Electron userData.
-const DATA_DIR = process.env.CLAUDE_CONFIG_DIR
-  ? path.join(process.env.CLAUDE_CONFIG_DIR, 'usage-monitor')
-  : path.join(os.homedir(), '.claude-usage-monitor')
-// when isolating per-account, also pin Electron's userData under DATA_DIR so two
-// widgets can run in parallel without fighting over cookies/cache. left untouched
-// in the default case so existing installs keep their window position etc.
-if (process.env.CLAUDE_CONFIG_DIR) {
-  fs.mkdirSync(DATA_DIR, { recursive: true })
-  app.setPath('userData', path.join(DATA_DIR, 'electron'))
-}
-// external config: edit without rebuilding the .app
-const EXTERNAL_CONFIG = path.join(DATA_DIR, 'config.json')
-// debug channel: `./pet <state>` writes here to force a state (dev only)
-const DEBUG_FILE = path.join(DATA_DIR, 'debug.json')
-// remembered floating-widget position: survives restarts and lets the widget
-// return to the monitor the user parked it on after a display is unplugged/replugged
-const WINDOW_STATE = path.join(DATA_DIR, 'window.json')
-
-let win
-let pollTimer
-let petPointerTimer
-let config
-let doTick = null
-const W = 304
-
-// menu-bar (tray) mode state
-let tray = null
-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 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
-
-function publicConfig(c) {
-  return {
-    plan: c.plan,
-    sessionTokenBudget: c.sessionTokenBudget,
-    weeklyTokenBudget: c.weeklyTokenBudget,
-    weeklyAnchorIso: c.weeklyAnchorIso,
-    mode: c.mode,
-    alerts: c.alerts,
-    alertThresholds: c.alertThresholds,
-    fireThreshold: c.fireThreshold,
-    zoom: c.zoom,
-    codex: !!c.codex?.enabled,
-    cursor: !!c.cursor?.enabled,
-    talk: c.talk,
-    sound: c.sound,
-    soundMutedUntil: c.soundMutedUntil,
-    pet: c.pet,
-  }
-}
-
-function loadConfig() {
-  const defaults = {
-    plan: 'max5x',
-    sessionTokenBudget: 630000000,
-    weeklyTokenBudget: 3450000000,
-    weeklyAnchorIso: null,
-    mode: 'floating', // 'floating' widget or 'menubar' popover
-    alerts: true,
-    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
-    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
-    pet: 'clauddy', // renderer/pets.js; holidays override it on their own days
-    pollIntervalMs: 4000,
-    activeThresholdMs: 20000,
-    sleepThresholdMs: 300000,
-  }
-  for (const p of [EXTERNAL_CONFIG, path.join(__dirname, 'config.json')]) {
-    try {
-      return { ...defaults, ...JSON.parse(fs.readFileSync(p, 'utf8')) }
-    } catch {}
-  }
-  return defaults
-}
-
-// ---- alerts ------------------------------------------------------------------
-// One notification per (scope × threshold), re-armed when usage drops back below.
-// `armed` is persisted so relaunching at 85% doesn't repeat the 80% alert you
-// already dismissed; it also carries the last session % so a reset is detectable
-// across restarts.
-// per account: two subscriptions have separate windows, so an alert armed on
-// one says nothing about the other
-let alertsFile = path.join(DATA_DIR, 'alerts.json')
-let armed = new Set()
-let lastSessionPct = null
-function loadAlertState() {
-  try {
-    const j = JSON.parse(fs.readFileSync(alertsFile, 'utf8'))
-    armed = new Set(Array.isArray(j.armed) ? j.armed : [])
-    lastSessionPct = typeof j.lastSessionPct === 'number' ? j.lastSessionPct : null
-  } catch {} // first run, or a corrupted file: start from a clean slate
-}
-function saveAlertState() {
-  try {
-    fs.mkdirSync(path.dirname(alertsFile), { recursive: true })
-    fs.writeFileSync(alertsFile, JSON.stringify({ armed: [...armed], lastSessionPct }))
-  } catch {}
-}
-
-function fmtDuration(ms) {
-  const h = Math.floor(ms / 3600000)
-  const m = Math.floor((ms % 3600000) / 60000)
-  return h > 0 ? `${h}h ${m}m` : `${m}m`
-}
-// wall-clock time the window flips, in the machine's own locale + timezone
-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
-}
-
-function notify(title, body, { silent = true } = {}) {
-  if (!Notification.isSupported()) return
-  const n = new Notification({ title, body, silent })
-  n.on('click', showWidget) // the obvious gesture: bring the pet to the front
-  n.show()
-}
-
-// Explicit reminders survive restarts and belong to the account that armed them.
-const REMINDERS_FILE = path.join(DATA_DIR, 'reset-reminders.json')
-const resetReminders = createReminders({
-  now: () => Date.now(),
-  load: () => JSON.parse(fs.readFileSync(REMINDERS_FILE, 'utf8')),
-  save: (data) => {
-    fs.mkdirSync(DATA_DIR, { recursive: true })
-    const tmp = `${REMINDERS_FILE}.tmp`
-    fs.writeFileSync(tmp, JSON.stringify(data))
-    fs.renameSync(tmp, REMINDERS_FILE)
-  },
-})
-// 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: find('claude'),
-    codex: find('codex'),
-    cursor: find('cursor'),
-    error,
-  })
-}
-function cancelReminder(key) {
-  try {
-    resetReminders.cancel(key)
-    sendReminders()
-    return true
-  } catch (err) {
-    console.error('reset reminder:', err)
-    sendReminders('Could not cancel the reminder. Please try again.')
-    return false
-  }
-}
-function checkResetReminders() {
-  try {
-    for (const r of resetReminders.list()) {
-      const connected =
-        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 !== '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.`
-        : `${r.label}: the scheduled session reset time has arrived. Open usage to confirm the new budget.`
-      notify(
-        confirmed ? 'Your session budget is back' : 'Time to check your session budget',
-        message,
-      )
-      if (win && !win.isDestroyed())
-        win.webContents.send('reminder-due', { ...r, confirmed, isCurrent })
-    }
-    if (due.length) sendReminders()
-  } catch (err) {
-    console.error('reset reminder:', err)
-  }
-}
-ipcMain.on('set-reminder', (_e, provider, enabled) => {
-  if (!Object.hasOwn(NAMES, provider) || typeof enabled !== 'boolean') return
-  const key = reminderKey(provider)
-  if (!enabled) return cancelReminder(key)
-  const { session, readAt, freshAt, on } = serviceState(provider)
-  const at = readAt + (session?.resetMs || 0)
-  const connected = provider === 'claude' ? auth.isConnected() : on
-  if (
-    !connected ||
-    !freshAt ||
-    Date.now() - freshAt > 15 * 60000 ||
-    !Number.isFinite(session?.pct)
-  ) {
-    return sendReminders('Wait for a fresh usage reading before setting a reminder.')
-  }
-  try {
-    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.')
-    }
-    sendReminders()
-  } catch {
-    sendReminders('Could not save the reminder. Please try again.')
-  }
-})
-
-// the alert lines carry the reset, since "what do I do about it" is a question
-// about time left, not about the threshold that happened to fire
-function resetLine(resetMs, withRemaining) {
-  if (resetMs == null) return ''
-  const at = `resets ${fmtClock(resetMs)}`
-  return withRemaining && resetMs > 0 ? `${fmtDuration(resetMs)} left · ${at}` : at
-}
-
-// usage crossing a threshold. `scopes` are {label, pct, resetMs, session} rows;
-// the real (OAuth) numbers are preferred over the local token estimate, which is
-// only a budget guess and can be off by an order of magnitude.
-function alertScopes(config, scopes) {
-  if (!config.alerts) return
-  const ths = config.alertThresholds || [80, 95]
-  const top = Math.max(...ths)
-  let dirty = false
-  for (const { label, pct, resetMs, session } of scopes) {
-    if (pct == null) continue
-    for (const t of ths) {
-      const key = `${label}:${t}`
-      if (pct >= t) {
-        if (!armed.has(key)) {
-          armed.add(key)
-          dirty = true
-          const urgent = t === top
-          notify(
-            `${label} at ${Math.round(pct)}%${urgent ? ' — almost out' : ''}`,
-            resetLine(resetMs, session),
-            { silent: !urgent }, // 80% is a heads-up; the last threshold earns a sound
-          )
-        }
-      } else if (armed.delete(key)) {
-        dirty = true // re-arm when it drops below
-      }
-    }
-  }
-  if (dirty) saveAlertState()
-}
-
-function checkAlerts(config, d) {
-  const r = realUsage // authoritative when logged in; the estimate is the fallback
-  const session = r?.session ?? d.session
-  const week = r?.week ?? d.week
-  alertScopes(config, [
-    { label: 'Session', pct: session.pct, resetMs: session.resetMs, session: true },
-    { label: 'Weekly usage', pct: week.pct, resetMs: week.resetMs },
-  ])
-  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, [
-    {
-      // a weekly-only plan carries its week in `session`, so the key says weekly
-      label: c.weeklyOnly ? 'Codex weekly' : 'Codex session',
-      pct: c.session?.pct,
-      resetMs: c.session?.resetMs,
-      session: true,
-    },
-    { 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) {
-  alertScopes(
-    config,
-    (u?.scoped || []).map((s) => ({
-      label: `${s.label} weekly`,
-      pct: s.pct,
-      resetMs: s.resetMs,
-    })),
-  )
-}
-
-// "you can work again" — only worth saying to someone who was actually near the
-// ceiling, so a window flipping at 20% stays silent
-const RESET_FROM = 80
-const RESET_TO = 5
-function checkWindowReset(config, pct) {
-  if (pct == null) return
-  const was = lastSessionPct
-  lastSessionPct = pct
-  if (
-    config.alerts &&
-    was != null &&
-    was >= RESET_FROM &&
-    pct <= RESET_TO &&
-    !resetReminders.list().some((r) => r.key === reminderKey('claude')) &&
-    !resetReminders.recentlyDelivered(reminderKey('claude'))
-  ) {
-    notify('Session window reset', 'full budget again')
-  }
-  if (was == null || Math.round(was) !== Math.round(pct)) saveAlertState()
-}
-
-// the token going dead is a silent failure otherwise: the widget quietly falls
-// back to the local estimate and keeps showing a number the user trusts
-function alertAuthLost(config) {
-  if (!config.alerts) return
-  notify('Clauddy lost access to your usage', 'open Settings to reconnect')
-}
-
-// ---- accounts ----------------------------------------------------------------
-// One widget, several Claude subscriptions. Switching rebinds the token store
-// (auth), the log dir (usage) and the alert state — everything that is "whose
-// usage is this" — while the window itself (position, mode, zoom, settings)
-// stays global, because there is only one pet.
-function applyAccount(acc) {
-  const dir = accounts.dataDirOf(acc.id)
-  alertsFile = path.join(dir, 'alerts.json')
-  auth.setDataDir(dir)
-  usage.setClaudeDir(acc.claudeDir)
-  armed = new Set()
-  lastSessionPct = null
-  lastSeenTokens = null // the new account's first read is a baseline, not a spend
-  loadAlertState()
-  sendReminders()
-}
-
-// `connected` is read off disk rather than through auth, which only ever knows
-// about the active account
-function accountsPayload() {
-  return {
-    active: accounts.activeId(),
-    accounts: accounts.list().map((a) => ({
-      id: a.id,
-      label: a.label,
-      connected: hasToken(a.id),
-    })),
-  }
-}
-
-// `busy` is the account being switched to, while its usage is still loading
-function sendAccounts(busy = null) {
-  if (win && !win.isDestroyed()) win.webContents.send('accounts', { ...accountsPayload(), busy })
-}
-
-// the numbers on screen belong to the old account: drop them before the new
-// account's first poll lands, so nothing stale is ever attributed to it
-function switchAccount(id) {
-  const leaving = accounts.activeId()
-  if (id === leaving) return
-  const acc = accounts.setActive(id)
-  if (!acc) return
-  saveAlertState() // the account we're leaving keeps what it had armed
-  pruneEmpty(leaving)
-  applyAccount(acc)
-  clearTimeout(usageTimer)
-  usageBackoff = 5 * 60 * 1000
-  pushRealUsage(null)
-  if (win && !win.isDestroyed()) {
-    win.webContents.send('auth-state', { connected: auth.isConnected() })
-    win.webContents.send('profile', null)
-  }
-  profileShown = false
-  sendAccounts(id) // the row goes pending right away…
-
-  // …because the rest is synchronous and slow: re-reading the new account's
-  // logs walks every .jsonl under its projects dir, which blocks this process
-  // for a beat on a busy machine. Yielding first lets the renderer paint the
-  // pending state instead of freezing mid-click.
-  setTimeout(() => {
-    if (doTick) doTick()
-    startUsagePoll()
-    sendProfile()
-    updateTray()
-    sendAccounts()
-  }, 0)
-}
-
-// a slot only earns its place by holding a login. One that was never connected
-// — the browser flow abandoned, or "add" clicked twice — is dropped the moment
-// we leave it, so the list can't fill up with "Not connected yet".
-// asked of any account, not just the active one — auth only knows about the
-// dir it is currently pointed at
-function hasToken(id) {
-  return fs.existsSync(path.join(accounts.dataDirOf(id), 'auth.json'))
-}
-
-function pruneEmpty(id) {
-  if (id === accounts.DEFAULT_ID || id === accounts.activeId()) return // never auto-drop the original
-  const acc = accounts.list().find((a) => a.id === id)
-  if (!acc || acc.label || hasToken(id)) return
-  accounts.remove(id)
-}
-
-ipcMain.on('accounts-switch', (_e, id) => switchAccount(String(id)))
-// "add an account" *is* "log in": the browser opens on the new, empty slot, so
-// the token lands in it and not in the account we just left
-// the account an "add" left behind: cancelling the login has to land back on
-// it, or the widget is stuck on an empty slot with no chip to switch from
-let addedFrom = null
-ipcMain.on('accounts-add', () => {
-  addedFrom = accounts.activeId()
-  switchAccount(accounts.add())
-  startLogin()
-})
-ipcMain.on('accounts-cancel-add', () => {
-  const from = addedFrom
-  addedFrom = null
-  if (!from || from === accounts.activeId() || hasToken(accounts.activeId())) return
-  switchAccount(from) // the empty slot is pruned on the way out
-})
-ipcMain.on('accounts-remove', (_e, id) => {
-  if (accounts.remove(String(id))) {
-    cancelReminder(`claude:${id}`)
-    sendAccounts()
-  }
-})
-
-function createWindow() {
-  config = loadConfig()
-  // a login abandoned in an earlier run: nothing stays pending across a restart,
-  // so fall back to the first account and let the empty slots go
-  const boot = accounts.active()
-  if (!boot.label && !hasToken(boot.id)) {
-    // the default account can be gone by now, so land on whatever comes first
-    const fallback = accounts.list().find((a) => a.id !== boot.id)
-    if (fallback) accounts.setActive(fallback.id)
-  }
-  for (const a of accounts.list()) pruneEmpty(a.id)
-  accounts.pruneOrphans() // folders those slots left behind
-  applyAccount(accounts.active())
-  powerMonitor?.on?.('resume', onResume)
-  const { workAreaSize } = screen.getPrimaryDisplay()
-  const H = 480
-
-  win = new BrowserWindow({
-    width: W,
-    height: H,
-    x: workAreaSize.width - W - 24,
-    y: workAreaSize.height - H - 24,
-    frame: false,
-    transparent: true,
-    backgroundColor: '#00000000', // fully transparent — Windows needs this or the window paints black
-    resizable: false,
-    show: false, // applyMode() reveals it (floating) or keeps it a hidden popover (menubar)
-    alwaysOnTop: true,
-    // macOS: the widget is rarely the focused window, so without this the first
-    // click only focuses it and a button needs a second one
-    acceptFirstMouse: true,
-    skipTaskbar: true,
-    hasShadow: false,
-    fullscreenable: false,
-    icon: path.join(__dirname, 'build', 'icon.png'),
-    webPreferences: {
-      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',
-    },
-  })
-
-  win.setAlwaysOnTop(true, 'floating')
-  win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true })
-  win.loadFile(path.join(__dirname, 'renderer', 'index.html'))
-
-  // in menu-bar mode the popover dismisses when it loses focus (click elsewhere)
-  win.on('blur', () => {
-    if (currentMode === 'menubar' && win.isVisible()) {
-      win.hide()
-      lastBlurHide = Date.now()
-    }
-  })
-
-  // remember where the user parks the widget — but not the moves we make
-  // ourselves (resize re-anchoring) nor the ones the OS forces when a display
-  // (dis)connects, so a monitor going dark never overwrites the saved spot
-  win.on('moved', () => {
-    if (Date.now() - lastProgrammaticMove < 500) return
-    if (Date.now() - displayChanging < 2000) return
-    saveWindowState()
-  })
-
-  // when a monitor is unplugged/replugged (or its layout changes), put the
-  // floating widget back on the display the user parked it on — the OS dumps
-  // it on the primary display otherwise, and never moves it back on its own
-  const onDisplayChange = () => {
-    displayChanging = Date.now()
-    if (currentMode === 'floating' && win && !win.isDestroyed() && win.isVisible())
-      positionFloating()
-  }
-  screen.on('display-added', onDisplayChange)
-  screen.on('display-removed', onDisplayChange)
-  screen.on('display-metrics-changed', onDisplayChange)
-
-  const tick = () => {
-    if (!win || win.isDestroyed()) return
-    try {
-      const data = getUsage(config)
-      win.webContents.send('usage', data)
-      checkAlerts(config, data)
-      onLocalActivity(data)
-    } 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
-      codexReadAt = Date.now()
-      win.webContents.send('codex', c)
-      checkCodexAlerts(config, c)
-      updateTray()
-    } 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
-
-  win.webContents.once('did-finish-load', () => {
-    tick()
-    win.webContents.send('config', publicConfig(config))
-    win.webContents.send('version', app.getVersion())
-    sendReminders()
-    win.webContents.send('auth-state', { connected: auth.isConnected() })
-    sendAccounts()
-    pollTimer = setInterval(tick, config.pollIntervalMs)
-    startUsagePoll()
-    sendProfile()
-    watchDebug()
-    applyMode(config.mode) // reveal the widget, or set up the tray + popover
-    setTimeout(autoUpdateCheck, 8000) // check once shortly after launch…
-    setInterval(autoUpdateCheck, 6 * 60 * 60 * 1000) // …then every 6h
-  })
-}
-
-// ---- menu-bar (tray) mode ----------------------------------------------------
-// Floating mode: the widget lives bottom-right, always visible. Menu-bar mode:
-// the same window becomes a popover shown under a tray icon on click. Switching
-// is live — no relaunch — so the Settings toggle applies immediately.
-function applyMode(mode) {
-  const next = mode === 'menubar' ? 'menubar' : 'floating'
-  const changed = next !== currentMode
-  currentMode = next
-  if (currentMode === 'menubar') {
-    ensureTray()
-    win.setSkipTaskbar(true)
-    if (changed && win.isVisible()) win.hide() // hide only when switching in
-  } else {
-    destroyTray()
-    if (changed || !win.isVisible()) {
-      positionFloating()
-      win.show()
-    }
-  }
-  updateTray()
-}
-
-function ensureTray() {
-  if (tray) return
-  // macOS recolors a "template" (black+alpha) image for the light/dark menu
-  // bar; Linux/Windows tray icons get no such recoloring, so they get the
-  // pre-colored terracotta variant instead — a plain black icon disappears
-  // on dark panels (e.g. Linux Mint's default Cinnamon taskbar).
-  const isMac = process.platform === 'darwin'
-  const iconFile = isMac ? 'trayTemplate.png' : 'trayColor.png'
-  const img = nativeImage.createFromPath(path.join(__dirname, 'build', iconFile))
-  if (isMac) img.setTemplateImage(true)
-  tray = new Tray(img)
-  tray.setToolTip('Clauddy')
-  tray.on('click', (_e, bounds) => {
-    trayBounds = bounds
-    togglePopover()
-  })
-  tray.on('right-click', () => tray.popUpContextMenu(trayMenu()))
-}
-
-function destroyTray() {
-  if (tray) {
-    tray.destroy()
-    tray = null
-  }
-}
-
-// the accounts entry only earns its place once there's more than one
-function accountsMenuItems() {
-  const list = accounts.list()
-  if (list.length < 2) return []
-  const activeId = accounts.activeId()
-  return [
-    {
-      label: 'Account',
-      submenu: list.map((a) => ({
-        label: a.label || 'Not connected',
-        type: 'radio',
-        checked: a.id === activeId,
-        click: () => switchAccount(a.id),
-      })),
-    },
-  ]
-}
-
-function trayMenu() {
-  return Menu.buildFromTemplate([
-    { label: 'Open Clauddy', click: () => showPopover() },
-    ...accountsMenuItems(),
-    ...(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() },
-  ])
-}
-
-function togglePopover() {
-  if (Date.now() - lastBlurHide < 250) return // this click just dismissed it
-  if (win.isVisible()) win.hide()
-  else showPopover()
-}
-
-function showPopover() {
-  positionUnderTray()
-  win.show()
-  win.focus()
-}
-
-// bring the widget to the front from wherever it is, in either mode
-function showWidget() {
-  if (!win || win.isDestroyed()) return
-  if (currentMode === 'menubar') showPopover()
-  else {
-    win.show()
-    win.focus()
-  }
-}
-
-// route every programmatic move through here so the 'moved' handler can tell
-// our own repositioning apart from a genuine user drag (and skip saving it)
-function moveWindow(x, y) {
-  lastProgrammaticMove = Date.now()
-  win.setPosition(Math.round(x), Math.round(y))
-}
-
-// persist the widget's anchor — its bottom-right corner, since the window's
-// size changes as the pet animates — so it can be restored later
-function saveWindowState() {
-  if (currentMode !== 'floating' || !win || win.isDestroyed()) return
-  const b = win.getBounds()
-  try {
-    fs.mkdirSync(DATA_DIR, { recursive: true })
-    fs.writeFileSync(WINDOW_STATE, JSON.stringify({ right: b.x + b.width, bottom: b.y + b.height }))
-  } catch {}
-}
-
-function loadWindowState() {
-  try {
-    const s = JSON.parse(fs.readFileSync(WINDOW_STATE, 'utf8'))
-    return Number.isFinite(s?.right) && Number.isFinite(s?.bottom) ? s : null
-  } catch {
-    return null
-  }
-}
-
-// is the saved bottom-right corner on a display that's currently connected?
-function cornerVisible(right, bottom) {
-  const x = Math.round(right - 1)
-  const y = Math.round(bottom - 1)
-  return screen.getAllDisplays().some((d) => {
-    const b = d.bounds
-    return x >= b.x && x < b.x + b.width && y >= b.y && y < b.y + b.height
-  })
-}
-
-// center the popover under the tray icon, kept on-screen
-function positionUnderTray() {
-  const b = win.getBounds()
-  const { workAreaSize } = screen.getPrimaryDisplay()
-  let x = workAreaSize.width - b.width - 24
-  let y = 24
-  if (trayBounds?.width) {
-    x = Math.round(trayBounds.x + trayBounds.width / 2 - b.width / 2)
-    y = Math.round(trayBounds.y + trayBounds.height)
-  }
-  x = Math.max(8, Math.min(x, workAreaSize.width - b.width - 8))
-  moveWindow(x, y)
-  // the popover's nib points at the icon, even when the screen edge pushed the
-  // window off-centre
-  const iconX = trayBounds?.width ? trayBounds.x + trayBounds.width / 2 : x + b.width / 2
-  win.webContents.send('popover-anchor', Math.round(iconX - x))
-}
-
-function positionFloating() {
-  const b = win.getBounds()
-  // reuse the saved spot when that monitor is still connected; otherwise fall
-  // back to the primary display's bottom-right corner
-  const saved = loadWindowState()
-  if (saved && cornerVisible(saved.right, saved.bottom)) {
-    moveWindow(saved.right - b.width, saved.bottom - b.height)
-    return
-  }
-  const { workAreaSize } = screen.getPrimaryDisplay()
-  moveWindow(workAreaSize.width - b.width - 24, workAreaSize.height - b.height - 24)
-}
-
-// the tray shows the live session % (macOS title), turning 🔥 near the limit
-function updateTray() {
-  if (!tray) return
-  const cx = codexUsage
-  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 age = (u) => (u.limitsAt ? ` (as of ${new Date(u.limitsAt).toLocaleTimeString()})` : '')
-    const parts = [
-      sessionPct != null && ['C', `Claude session ${fmt(sessionPct)}`, sessionPct],
-      cx && [
-        'X',
-        `Codex ${cx.weeklyOnly ? 'weekly' : '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}`)
-    tray.setToolTip(`Clauddy — ${parts.map(([, t]) => t).join(' · ')}`)
-    return
-  }
-  if (sessionPct == null) {
-    if (process.platform === 'darwin') tray.setTitle('')
-    tray.setToolTip('Clauddy — connect your account for live %')
-    return
-  }
-  const pct = Math.round(sessionPct)
-  const hot = pct >= (config?.fireThreshold ?? 90)
-  if (process.platform === 'darwin') tray.setTitle(hot ? ` ${pct}% 🔥` : ` ${pct}%`)
-  tray.setToolTip(`Clauddy — session ${pct}%`)
-}
-
-// send real usage to the renderer and refresh the tray title in one place
-function pushRealUsage(u) {
-  realUsage = u
-  realUsageAt = u ? Date.now() : 0
-  sessionPct = u?.session ? u.session.pct : null
-  updateTray()
-  checkScopedAlerts(config, u)
-  if (win && !win.isDestroyed()) win.webContents.send('real-usage', u)
-}
-
-// Native drag regions swallow renderer pointer events. Poll only in pet-only
-// mode so its hover still works while the sprite remains a native drag handle.
-ipcMain.on('pet-pointer-watch', (_e, enabled) => {
-  if (typeof enabled !== 'boolean') return
-  clearInterval(petPointerTimer)
-  petPointerTimer = null
-  if (!enabled) return
-  let last // only a moved cursor crosses IPC, not ten idle messages a second
-  petPointerTimer = setInterval(() => {
-    if (!win || win.isDestroyed()) return
-    let point = null
-    if (win.isVisible()) {
-      const cursor = screen.getCursorScreenPoint()
-      const bounds = win.getContentBounds()
-      const x = cursor.x - bounds.x
-      const y = cursor.y - bounds.y
-      if (x >= 0 && y >= 0 && x < bounds.width && y < bounds.height) point = { x, y }
-    }
-    const key = point ? `${point.x},${point.y}` : ''
-    if (key === last) return
-    last = key
-    win.webContents.send('pet-pointer', point)
-  }, 100)
-})
-
-// resize the window to fit the content
-// Opening and closing Settings eases the window between sizes (an ease-out over
-// RESIZE_MS) instead of jumping; any other resize is immediate and cancels a
-// tween still running, so the latest size always wins.
-const RESIZE_MS = 240
-let resizeTween = null
-ipcMain.on('resize', (_e, w, h, animate) => {
-  if (!win || win.isDestroyed()) return
-  const width = Math.max(100, Math.round(w))
-  const height = Math.max(110, Math.round(h))
-  clearInterval(resizeTween)
-  resizeTween = null
-  if (!animate) return setWindowSize(width, height)
-  const from = win.getBounds()
-  const start = Date.now()
-  const step = () => {
-    if (!win || win.isDestroyed()) return clearInterval(resizeTween)
-    const t = Math.min(1, (Date.now() - start) / RESIZE_MS)
-    const k = 1 - (1 - t) ** 3
-    setWindowSize(
-      Math.round(from.width + (width - from.width) * k),
-      Math.round(from.height + (height - from.height) * k),
-    )
-    if (t === 1) {
-      clearInterval(resizeTween)
-      resizeTween = null
-    }
-  }
-  resizeTween = setInterval(step, 16)
-  step()
-})
-
-function setWindowSize(width, height) {
-  if (currentMode === 'menubar') {
-    win.setContentSize(width, height)
-    if (win.isVisible()) positionUnderTray() // keep it anchored under the tray
-  } else {
-    // keep the widget pinned to its current bottom-right corner on whatever
-    // display the user dragged it to. setContentSize grows from the top-left
-    // origin, so re-anchor by the old corner instead of snapping to the primary
-    // display's bottom-right (which yanked the widget back on every update).
-    const before = win.getBounds()
-    const right = before.x + before.width
-    const bottom = before.y + before.height
-    win.setContentSize(width, height)
-    const after = win.getBounds()
-    moveWindow(right - after.width, bottom - after.height)
-  }
-}
-
-// 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))
-
-// 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 }, () => {
-    if (!win || win.isDestroyed()) return
-    try {
-      const txt = fs.readFileSync(DEBUG_FILE, 'utf8').trim()
-      win.webContents.send('debug-state', txt ? JSON.parse(txt) : null)
-    } catch {}
-  })
-}
-
-// ---- real usage via OAuth (authoritative %), polled slowly with 429 backoff ----
-let usageTimer = null
-let usageBackoff = 5 * 60 * 1000
-let authFails = 0 // consecutive 401s — see pollUsage
-let lastPollAt = 0
-
-// The authoritative % only moves when tokens are actually spent, and the local
-// logs show that within a tick. Polling off that beats a faster clock: it
-// answers while the user is working and asks for nothing while they are not.
-// The floor is what bounds the cost — never more than one call per 90s, well
-// under what a fixed one-minute poll would spend.
-const POLL_FLOOR_MS = 90 * 1000
-let lastSeenTokens = null
-function onLocalActivity(data) {
-  const t = data?.session?.tokens
-  if (typeof t !== 'number') return
-  const grew = lastSeenTokens != null && t > lastSeenTokens
-  lastSeenTokens = t
-  if (!grew || !auth.isConnected()) return
-  if (Date.now() - lastPollAt < POLL_FLOOR_MS) return
-  clearTimeout(usageTimer) // pollUsage schedules the next heartbeat itself
-  pollUsage()
-}
-
-function scheduleUsagePoll() {
-  clearTimeout(usageTimer)
-  if (auth.isConnected()) usageTimer = setTimeout(pollUsage, usageBackoff)
-}
-async function pollUsage() {
-  const accountId = accounts.activeId()
-  lastPollAt = Date.now()
-  try {
-    const u = await auth.fetchUsage()
-    if (accountId !== accounts.activeId()) return
-    usageBackoff = 5 * 60 * 1000
-    authFails = 0
-    pushRealUsage(u)
-    // a token that came back after being cleared (a refresh that landed late)
-    // brings the % back, but nothing re-sent the chip: restate who this is
-    if (!profileShown) {
-      if (win && !win.isDestroyed()) win.webContents.send('auth-state', { connected: true })
-      sendAccounts()
-      sendProfile()
-    }
-  } catch (e) {
-    if (accountId !== accounts.activeId()) return
-    if (e && e.status === 429) {
-      usageBackoff = Math.min(usageBackoff * 2, 30 * 60 * 1000)
-    } else if (e && e.status === 401) {
-      // Refreshing rotates the refresh token, so a request that raced the one
-      // that rotated it comes back rejected while the session is perfectly
-      // alive. Clearing on that first answer throws away a good login, so the
-      // second rejection in a row is what counts.
-      if (++authFails < 2) {
-        usageBackoff = 60 * 1000
-        scheduleUsagePoll()
-        return
-      }
-      auth.clear()
-      pushRealUsage(null)
-      sendAccounts()
-      alertAuthLost(config)
-      if (win && !win.isDestroyed()) {
-        win.webContents.send('auth-state', { connected: false })
-        win.webContents.send('profile', null)
-      }
-      profileShown = false
-    }
-  }
-  scheduleUsagePoll()
-}
-function startUsagePoll() {
-  authFails = 0
-  if (auth.isConnected()) pollUsage()
-}
-
-// Waking up: the poll timer was frozen through the sleep, so the numbers on
-// screen are as old as the nap. Re-state what we know — a read that failed on
-// the way down would otherwise leave a stale "log in" panel up — and poll
-// again, after a beat, since the network is rarely back the instant we are.
-function onResume() {
-  if (!auth.isConnected()) return
-  if (win && !win.isDestroyed()) win.webContents.send('auth-state', { connected: true })
-  clearTimeout(usageTimer)
-  usageBackoff = 5 * 60 * 1000
-  usageTimer = setTimeout(pollUsage, 5000)
-  sendProfile()
-}
-
-// push the logged-in account's identity (email + plan) to the renderer
-let profileTimer = null
-let profileShown = false // the renderer holds this account's profile
-async function sendProfile(tries = 0) {
-  clearTimeout(profileTimer)
-  if (!auth.isConnected()) return
-  // whose profile this is, decided *before* the await: a switch during the
-  // fetch would otherwise label the new account with the old one's email
-  const id = accounts.activeId()
-  try {
-    const p = await auth.fetchProfile()
-    if (id !== accounts.activeId()) return // switched under us — this is stale
-    if (p?.email) {
-      accounts.label(id, p.email) // a better name than "acct-xyz"
-      sendAccounts()
-    }
-    if (win && !win.isDestroyed()) win.webContents.send('profile', p)
-    profileShown = true
-  } catch {
-    // a rate limit or a blip would otherwise hide the chip — and with it the
-    // account switcher — until the app is restarted, so keep trying for a while
-    if (tries >= 4) return
-    profileTimer = setTimeout(
-      () => {
-        if (id === accounts.activeId()) sendProfile(tries + 1)
-      },
-      30 * 1000 * 2 ** tries,
-    )
-  }
-}
-
-// begin() has to run *after* any account switch: switching resets the pending
-// PKCE verifier, which would strand a login started before it
-function startLogin() {
-  shell.openExternal(auth.begin())
-  if (win && !win.isDestroyed()) win.webContents.send('auth-pending')
-}
-ipcMain.on('auth-start', startLogin)
-ipcMain.on('auth-code', async (_e, code) => {
-  const ok = () => {
-    addedFrom = null // the new account is real now: nothing to roll back to
-    if (win && !win.isDestroyed()) {
-      win.webContents.send('auth-state', { connected: true })
-      win.webContents.send('auth-result', { ok: true })
-    }
-    sendAccounts()
-    sendProfile()
-  }
-  try {
-    await auth.complete(code)
-    usageBackoff = 5 * 60 * 1000
-    try {
-      const u = await auth.fetchUsage() // validate the token
-      ok()
-      pushRealUsage(u)
-    } catch (e) {
-      if (e && e.status === 429) {
-        // token is fine, the usage endpoint is just throttled — keep it and retry later
-        ok()
-      } else {
-        throw e
-      }
-    }
-    scheduleUsagePoll()
-  } catch (err) {
-    auth.clear() // don't keep an invalid token
-    if (win && !win.isDestroyed())
-      win.webContents.send('auth-result', { ok: false, error: String(err?.message || err) })
-  }
-})
-ipcMain.on('auth-logout', () => {
-  cancelReminder(reminderKey('claude'))
-  auth.clear()
-  clearTimeout(usageTimer)
-  pushRealUsage(null)
-  sendAccounts()
-  if (win && !win.isDestroyed()) {
-    win.webContents.send('auth-state', { connected: false })
-    win.webContents.send('profile', null)
-  }
-  profileShown = false
-})
-
-// 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
-    cancelReminder('codex')
-  }
-  if (win && !win.isDestroyed()) win.webContents.send('config', publicConfig(config))
-  if (doTick) doTick()
-  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')]) {
-    try {
-      obj = JSON.parse(fs.readFileSync(p, 'utf8'))
-      break
-    } catch {}
-  }
-  Object.assign(obj, patch)
-  try {
-    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
-  // (zoom, mode…) shouldn't replay an alert the user already dismissed
-  if (String(config.alertThresholds) !== prevThresholds) {
-    armed.clear()
-    saveAlertState()
-  }
-  if (doTick) doTick()
-  if (win && !win.isDestroyed()) win.webContents.send('config', publicConfig(config))
-  applyMode(config.mode) // switch between floating widget and menu-bar popover live
-})
-
-// ---- self-update (checks the latest GitHub release, runs install.sh) ---------
-async function fetchLatestTag() {
-  const res = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, {
-    headers: { 'User-Agent': 'Clauddy', Accept: 'application/vnd.github+json' },
-  })
-  if (!res.ok) throw new Error(`HTTP ${res.status}`)
-  const j = await res.json()
-  return j.tag_name // e.g. "v1.9.1"
-}
-// compare two "1.2.3" versions; >0 if a is newer than b
-function cmpVer(a, b) {
-  const pa = String(a).replace(/^v/, '').split('.').map(Number)
-  const pb = String(b).replace(/^v/, '').split('.').map(Number)
-  for (let i = 0; i < 3; i++) {
-    const d = (pa[i] || 0) - (pb[i] || 0)
-    if (d) return d > 0 ? 1 : -1
-  }
-  return 0
-}
-async function computeUpdate() {
-  const latest = await fetchLatestTag()
-  return { latest, available: cmpVer(latest, app.getVersion()) > 0 }
-}
-// manual check (from the Settings button): shows checking / result / error
-ipcMain.on('check-updates', async () => {
-  if (!win || win.isDestroyed()) return
-  const send = (s) => !win.isDestroyed() && win.webContents.send('update-status', s)
-  send({ state: 'checking' })
-  try {
-    const u = await computeUpdate()
-    send(u.available ? { state: 'available', latest: u.latest } : { state: 'uptodate' })
-  } catch (e) {
-    send({ state: 'error', message: String(e?.message || e) })
-  }
-})
-// silent background check: only speaks up when there's actually an update, so
-// the renderer can badge the gear without any UI churn on the common case
-async function autoUpdateCheck() {
-  if (!win || win.isDestroyed()) return
-  try {
-    const u = await computeUpdate()
-    if (u.available) win.webContents.send('update-status', { state: 'available', latest: u.latest })
-  } catch {} // offline / rate-limited: stay quiet, try again on the next tick
-}
-ipcMain.on('do-update', () => {
-  // Windows/Linux have no install.sh: send them to the releases page instead.
-  if (process.platform !== 'darwin') {
-    shell.openExternal(`https://github.com/${REPO}/releases/latest`)
-    return
-  }
-  if (win && !win.isDestroyed()) win.webContents.send('update-status', { state: 'updating' })
-  const cmd = `curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash`
-  const child = spawn('/bin/bash', ['-lc', cmd], { detached: true, stdio: 'ignore' })
-  child.unref()
-  // quit so the installer can replace the running .app and relaunch the new build
-  setTimeout(() => app.quit(), 1500)
-})
-
-ipcMain.on('quit', () => app.quit())
-
-// Electron's login-item API only covers macOS (SMAppService) and Windows (the
-// registry Run key) — @platform darwin,win32 in electron.d.ts, a no-op on
-// Linux. The real "start with the system" mechanism there is the XDG
-// Autostart spec: a .desktop file in ~/.config/autostart, read by every major
-// desktop environment's session manager at login (GNOME, KDE, XFCE, Cinnamon,
-// MATE) — same role as the registry key or SMAppService, just file-based.
-function enableLinuxAutostart() {
-  const exec = process.env.APPIMAGE || process.execPath
-  const autostartDir = path.join(os.homedir(), '.config', 'autostart')
-  const desktopFile = path.join(autostartDir, 'clauddy.desktop')
-  // AppImage isn't registered in the system's hicolor icon theme, so a bare
-  // "Icon=clauddy" name won't resolve — copy the icon to a path that outlives
-  // the AppImage's temp mount and reference it absolutely instead.
-  const iconFile = path.join(DATA_DIR, 'icon.png')
-  fs.mkdirSync(DATA_DIR, { recursive: true })
-  fs.copyFileSync(path.join(__dirname, 'build', 'icon.png'), iconFile)
-  const entry = [
-    '[Desktop Entry]',
-    'Type=Application',
-    'Name=Clauddy',
-    'Comment=A cute pixel-art desktop pet that tracks your Claude Code usage',
-    `Exec="${exec}"`,
-    `Icon=${iconFile}`,
-    'Terminal=false',
-    'X-GNOME-Autostart-enabled=true',
-    '',
-  ].join('\n')
-  if (fs.existsSync(desktopFile) && fs.readFileSync(desktopFile, 'utf8') === entry) return
-  fs.mkdirSync(autostartDir, { recursive: true })
-  fs.writeFileSync(desktopFile, entry)
-}
-
-app.whenReady().then(() => {
-  // Windows toast notifications need an explicit AppUserModelID to show reliably
-  if (process.platform === 'win32') app.setAppUserModelId('app.clauddy')
-  createWindow()
-  // open at login (packaged app only)
-  if (app.isPackaged) {
-    if (process.platform === 'linux') {
-      enableLinuxAutostart()
-    } else {
-      app.setLoginItemSettings({ openAtLogin: true, openAsHidden: false })
-    }
-  }
-})
-
-app.on('window-all-closed', () => {
-  if (pollTimer) clearInterval(pollTimer)
-  clearInterval(petPointerTimer)
-  fs.unwatchFile(DEBUG_FILE)
-  destroyTray()
-  app.quit()
-})
-
-if (process.platform === 'darwin' && app.dock) app.dock.hide()