clauddy 1.29.0 → 2.0.0

package/preload.js

@@ -1,43 +0,0 @@
-const { contextBridge, ipcRenderer } = require('electron')
-
-contextBridge.exposeInMainWorld('api', {
-  watchPetPointer: (enabled) => ipcRenderer.send('pet-pointer-watch', enabled),
-  onPetPointer: (cb) => ipcRenderer.on('pet-pointer', (_e, point) => cb(point)),
-  setReminder: (provider, enabled) => ipcRenderer.send('set-reminder', provider, enabled),
-  onReminders: (cb) => ipcRenderer.on('reminders', (_e, state) => cb(state)),
-  onReminderDue: (cb) => ipcRenderer.on('reminder-due', (_e, event) => cb(event)),
-  onUsage: (cb) => ipcRenderer.on('usage', (_e, data) => cb(data)),
-  onError: (cb) => ipcRenderer.on('usage-error', (_e, msg) => cb(msg)),
-  onConfig: (cb) => ipcRenderer.on('config', (_e, cfg) => cb(cfg)),
-  saveConfig: (patch) => ipcRenderer.send('save-config', patch),
-  resize: (w, h, animate) => ipcRenderer.send('resize', w, h, animate),
-  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)),
-  cursorDetect: () => ipcRenderer.send('cursor-detect'),
-  onCursorDetected: (cb) => ipcRenderer.on('cursor-detected', (_e, r) => cb(r)),
-  cursorEnable: (on) => ipcRenderer.send('cursor-enable', on),
-  onCursor: (cb) => ipcRenderer.on('cursor', (_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)),
-  onAuthPending: (cb) => ipcRenderer.on('auth-pending', () => cb()),
-  onAuthResult: (cb) => ipcRenderer.on('auth-result', (_e, r) => cb(r)),
-  authStart: () => ipcRenderer.send('auth-start'),
-  authCode: (code) => ipcRenderer.send('auth-code', code),
-  authLogout: () => ipcRenderer.send('auth-logout'),
-  onAccounts: (cb) => ipcRenderer.on('accounts', (_e, a) => cb(a)),
-  accountSwitch: (id) => ipcRenderer.send('accounts-switch', id),
-  accountAdd: () => ipcRenderer.send('accounts-add'),
-  accountCancelAdd: () => ipcRenderer.send('accounts-cancel-add'),
-  accountRemove: (id) => ipcRenderer.send('accounts-remove', id),
-  onDebugState: (cb) => ipcRenderer.on('debug-state', (_e, s) => cb(s)),
-  onVersion: (cb) => ipcRenderer.on('version', (_e, v) => cb(v)),
-  onUpdateStatus: (cb) => ipcRenderer.on('update-status', (_e, s) => cb(s)),
-  onPopoverAnchor: (cb) => ipcRenderer.on('popover-anchor', (_e, x) => cb(x)),
-  checkUpdates: () => ipcRenderer.send('check-updates'),
-  doUpdate: () => ipcRenderer.send('do-update'),
-  quit: () => ipcRenderer.send('quit'),
-})

package/reminders.js

@@ -1,54 +0,0 @@
-// One-shot reset reminders, independent of automatic threshold alerts.
-function createReminders({ load, save, now = Date.now }) {
-  let pending = []
-  let delivered = {}
-  const valid = (r) =>
-    r &&
-    ['claude', 'codex', 'cursor'].includes(r.provider) &&
-    typeof r.key === 'string' &&
-    typeof r.label === 'string' &&
-    Number.isFinite(r.at) &&
-    Number.isFinite(r.pct)
-  try {
-    const data = load()
-    pending = Array.isArray(data?.pending) ? data.pending.filter(valid) : []
-    delivered = data?.delivered || {}
-  } catch {}
-  function persist(nextPending, nextDelivered = delivered) {
-    const recent = Object.fromEntries(
-      Object.entries(nextDelivered).filter(([, at]) => Number.isFinite(at) && now() - at < 3600000),
-    )
-    save({ pending: nextPending, delivered: recent })
-    pending = nextPending
-    delivered = recent
-  }
-  return {
-    list: () => pending.map((r) => ({ ...r })),
-    arm(reminder) {
-      // Cursor's budget is a billing cycle, so a reset can be a month out
-      if (!valid(reminder) || reminder.at <= now() || reminder.at > now() + 32 * 86400000)
-        return false
-      persist([...pending.filter((r) => r.key !== reminder.key), { ...reminder }])
-      return true
-    },
-    cancel(key) {
-      const found = pending.some((r) => r.key === key)
-      if (found) persist(pending.filter((r) => r.key !== key))
-    },
-    takeDue() {
-      const due = pending.filter((r) => r.at <= now())
-      if (!due.length) return []
-      const nextDelivered = { ...delivered }
-      for (const r of due) nextDelivered[r.key] = now()
-      // Consume before delivering: restart must not replay it.
-      persist(
-        pending.filter((r) => r.at > now()),
-        nextDelivered,
-      )
-      return due
-    },
-    recentlyDelivered: (key) => Number.isFinite(delivered[key]) && now() - delivered[key] < 3600000,
-  }
-}
-
-module.exports = { createReminders }

package/renderer/burn.js

@@ -1,98 +0,0 @@
-// ---- burn-rate projection ----
-// The panel knows where you are (82%) and when the window resets (1h 12m); it
-// can also say where you're headed — fit a slope through recent usage and
-// project the crossing of 100%. If the reset lands first there's nothing to
-// worry about, which is worth saying out loud rather than leaving blank.
-//
-// The slope is fitted over session *tokens*, not the account %. The % is the
-// number we ultimately care about, but it arrives as a whole number every ~5
-// min: over a short window the whole signal is a single 16 → 17 step, which
-// makes the fitted pace wrong by multiples. Local-log tokens step too — one
-// jump per assistant turn, with plateaus in between — but in increments some
-// 10-20x finer, so they carry a far steadier slope. The account % still anchors
-// it: pct/tokens converts tokens/ms into %/ms and re-calibrates on every poll,
-// so the projection stays tied to the real number.
-//
-// Loaded both as a plain <script> by the renderer (exposing `Burn`) and via
-// require() by the tests — hence the dual export at the bottom.
-;(() => {
-  const WINDOW_MS = 45 * 60 * 1000 // only fit recent samples — pace changes
-  const MIN_SAMPLES = 4
-  const MIN_SPAN_MS = 5 * 60 * 1000 // shorter than a % fit affords, and steadier
-  const SAMPLE_EVERY_MS = 30 * 1000 // usage polls every few seconds; thin it out
-
-  // `now` is injectable so tests can drive the trail without sleeping
-  function createBurnTracker() {
-    let trail = []
-
-    function note(tokens, active, now = Date.now()) {
-      if (!active || !(tokens > 0)) {
-        trail = [] // no session, no trend
-        return
-      }
-      // session tokens only climb within a window — a drop means it rolled
-      // over, and the fresh sample starts the new trail rather than being
-      // throttled away
-      let last = trail[trail.length - 1]
-      if (last && tokens < last.tokens) {
-        trail = []
-        last = undefined
-      }
-      if (last && now - last.t < SAMPLE_EVERY_MS) return
-      trail.push({ t: now, tokens })
-      trail = trail.filter((s) => s.t >= now - WINDOW_MS)
-    }
-
-    // least-squares slope in tokens per ms, or null when there isn't enough to say
-    function slope() {
-      if (trail.length < MIN_SAMPLES) return null
-      const span = trail[trail.length - 1].t - trail[0].t
-      if (span < MIN_SPAN_MS) return null
-      const n = trail.length
-      const t0 = trail[0].t
-      let sx = 0
-      let sy = 0
-      let sxy = 0
-      let sxx = 0
-      for (const s of trail) {
-        const x = s.t - t0
-        sx += x
-        sy += s.tokens
-        sxy += x * s.tokens
-        sxx += x * x
-      }
-      const denom = n * sxx - sx * sx
-      if (denom === 0) return null
-      return (n * sxy - sx * sy) / denom
-    }
-
-    // → { kind: 'eta', ms } when you'd run out first, { kind: 'safe' } when the
-    // reset beats you there, or null when we can't tell yet.
-    function project(pct, resetMs, tokens) {
-      if (!(pct > 0) || !(tokens > 0)) return null // no anchor to convert tokens → %
-      const tokPerMs = slope()
-      if (tokPerMs == null || tokPerMs <= 0) return null // idle or flat
-      const pctPerMs = tokPerMs * (pct / tokens)
-      const eta = (100 - pct) / pctPerMs
-      if (!Number.isFinite(eta) || eta <= 0) return null
-      if (resetMs != null && eta >= resetMs) return { kind: 'safe' }
-      return { kind: 'eta', ms: eta }
-    }
-
-    return {
-      note,
-      slope,
-      project,
-      reset: () => {
-        trail = []
-      },
-      get trail() {
-        return trail
-      },
-    }
-  }
-
-  const api = { createBurnTracker, WINDOW_MS, MIN_SAMPLES, MIN_SPAN_MS, SAMPLE_EVERY_MS }
-  if (typeof module === 'object' && module.exports) module.exports = api
-  else globalThis.Burn = api
-})()

package/renderer/companion.js

@@ -1,52 +0,0 @@
-// A quiet transition detector. Startup and reconnects establish a baseline;
-// inactivity is a pause, never proof that an agent finished its task.
-;((root) => {
-  function createActivityTracker({ now = Date.now, cooldown = 30000 } = {}) {
-    const seen = new Map()
-    let lastCue = -Infinity
-    return {
-      forget(provider) {
-        seen.delete(provider)
-      },
-      observe(provider, data) {
-        if (!data) {
-          seen.delete(provider)
-          return null
-        }
-        const next = { active: !!data.active, activity: data.activity || 'working' }
-        const previous = seen.get(provider)
-        seen.set(provider, next)
-        if (!previous) return null
-        const changed =
-          next.active !== previous.active || (next.active && next.activity !== previous.activity)
-        if (!changed || now() - lastCue < cooldown) return null
-        lastCue = now()
-        return { provider, activity: next.active ? next.activity : 'paused' }
-      },
-    }
-  }
-  // Activity freshness is separate from quota freshness: Codex can work while
-  // its last rate-limit reading is old. Ignore abandoned activity snapshots.
-  const FRESH_MS = 60000
-  const SLEEP_MS = 300000 // main's default sleepThresholdMs; Codex and Cursor have no flag of their own
-  // each source is its last payload, or null while it isn't connected
-  function currentActivity({ claude = null, codex = null, cursor = null } = {}, now = Date.now()) {
-    const fresh = (at) => Number.isFinite(at) && now - at <= FRESH_MS
-    const providers = []
-    if (claude?.active && fresh(claude.ts)) providers.push('claude')
-    if (codex?.active && fresh(codex.lastSeen)) providers.push('codex')
-    if (cursor?.active && fresh(cursor.lastSeen)) providers.push('cursor')
-    // Claude's and Cursor's logs say *what* they're doing; Codex's don't, and
-    // two workers share one scene
-    const solo = providers.length === 1 ? { claude, cursor }[providers[0]] : null
-    const activity = solo?.activity || 'working'
-    const idle = (s) => s && !!s.lastSeen && now - s.lastSeen >= SLEEP_MS
-    const asleep = [claude && !!claude.sleeping, idle(codex), idle(cursor)].filter(
-      (v) => v !== null && v !== undefined,
-    )
-    return { providers, activity, sleeping: asleep.length > 0 && asleep.every(Boolean) }
-  }
-  const api = { createActivityTracker, currentActivity }
-  if (typeof module === 'object' && module.exports) module.exports = api
-  else root.Companion = api
-})(globalThis)