clauddy 1.29.0 → 2.0.0

package/codex.js

@@ -1,236 +0,0 @@
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
-
-// Codex (CLI and the desktop app alike) writes one `rollout-*.jsonl` per
-// session under ~/.codex/sessions/YYYY/MM/DD. Its `token_count` events carry
-// both the token totals and the account's rate limits, so everything here comes
-// from local files — no login needed.
-let codexDir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
-
-function setCodexDir(dir) {
-  codexDir = dir || process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
-  fileCache.clear()
-}
-
-const DAY = 86400000
-const DAYS = 30
-const WEEK = 7 * DAY
-const ACTIVE_MS = 60000 // a rollout touched within the last minute = Codex working
-const DAY_MIN = 24 * 60
-const TOP_PROJECTS = 5 // same fold as Claude's panel
-
-// per file: how far we've read, plus what we got out of it. Rollouts only ever
-// grow, so a poll reads just the bytes appended since the last one.
-const fileCache = new Map()
-
-function blankSummary() {
-  return { offset: 0, rest: '', lastTotal: 0, events: [], limits: null, model: null, cwd: null }
-}
-
-// a token_count's rate limits. Codex reports several buckets; some (the
-// `premium` one on Plus, say) come with null windows — only a bucket with a
-// real window is worth showing.
-function limitsOf(rl, ts) {
-  if (!rl || (!rl.primary && !rl.secondary)) return null
-  const win = (w) =>
-    w && typeof w.used_percent === 'number'
-      ? { pct: w.used_percent, resetsAt: w.resets_at ? w.resets_at * 1000 : null }
-      : null
-  // Plus reports a 5-hour window and a weekly one; some plans (Pro Lite, say)
-  // only the weekly one, in the `primary` slot. Sort by length, not by slot.
-  let session = null
-  let weekly = null
-  for (const w of [rl.primary, rl.secondary]) {
-    const v = win(w)
-    if (!v) continue
-    const long = w.window_minutes != null ? w.window_minutes >= DAY_MIN : w === rl.secondary
-    if (long) weekly = v
-    else session = v
-  }
-  return { ts, plan: rl.plan_type || null, session, weekly }
-}
-
-function ingestLine(sum, line) {
-  // cheap filter before JSON.parse — rollouts are mostly message bodies
-  if (!line.includes('"token_count"') && !line.includes('"turn_context"')) return
-  let o
-  try {
-    o = JSON.parse(line)
-  } catch {
-    return
-  }
-  const p = o.payload || {}
-  const ts = Date.parse(o.timestamp) || 0
-  if (o.type === 'turn_context') {
-    if (p.model) sum.model = p.model
-    if (p.cwd) sum.cwd = p.cwd
-    return
-  }
-  if (p.type !== 'token_count') return
-  // totals are cumulative per session, and the same count is often emitted
-  // twice — the delta is what this event actually spent. The model and project
-  // are the ones in effect *now*, so a mid-session switch is attributed right.
-  const total = p.info?.total_token_usage?.total_tokens
-  if (typeof total === 'number' && total > sum.lastTotal) {
-    sum.events.push({ ts, tokens: total - sum.lastTotal, model: sum.model, cwd: sum.cwd })
-    sum.lastTotal = total
-  }
-  const lim = limitsOf(p.rate_limits, ts)
-  if (lim && (!sum.limits || lim.ts >= sum.limits.ts)) sum.limits = lim
-}
-
-function readFile(file, st) {
-  let sum = fileCache.get(file)
-  // shrunk or replaced: start over
-  if (!sum || st.size < sum.offset) sum = blankSummary()
-  if (st.size > sum.offset) {
-    const fd = fs.openSync(file, 'r')
-    try {
-      const buf = Buffer.alloc(st.size - sum.offset)
-      fs.readSync(fd, buf, 0, buf.length, sum.offset)
-      sum.offset = st.size
-      const lines = (sum.rest + buf.toString('utf8')).split('\n')
-      // the last piece may be a line still being written
-      sum.rest = lines.pop()
-      for (const line of lines) ingestLine(sum, line)
-    } finally {
-      fs.closeSync(fd)
-    }
-  }
-  sum.mtime = st.mtimeMs
-  fileCache.set(file, sum)
-  return sum
-}
-
-// every rollout, with its stat; `since` drops the ones untouched since then
-function rollouts(since) {
-  const out = []
-  const walk = (dir, depth) => {
-    let kids
-    try {
-      kids = fs.readdirSync(dir, { withFileTypes: true })
-    } catch {
-      return
-    }
-    for (const k of kids) {
-      const full = path.join(dir, k.name)
-      if (k.isDirectory() && depth < 3) walk(full, depth + 1)
-      else if (k.isFile() && k.name.endsWith('.jsonl')) {
-        try {
-          const st = fs.statSync(full)
-          if (st.mtimeMs >= since) out.push({ file: full, st })
-        } catch {}
-      }
-    }
-  }
-  walk(path.join(codexDir, 'sessions'), 0)
-  return out
-}
-
-// Is there a Codex session on this machine? The folder alone is not enough.
-function detectCodex() {
-  const files = rollouts(0)
-  if (!files.length) return { found: false, plan: null }
-  files.sort((a, b) => b.st.mtimeMs - a.st.mtimeMs)
-  let plan = null
-  for (const { file, st } of files.slice(0, 5)) {
-    const lim = readFile(file, st).limits
-    if (lim?.plan) {
-      plan = lim.plan
-      break
-    }
-  }
-  return { found: true, plan }
-}
-
-// A window whose reset has passed tells us nothing about today: the log is
-// older than the window, so the % is unknown until Codex writes a fresh one.
-function windowNow(w, now) {
-  if (!w) return null
-  const expired = w.resetsAt != null && w.resetsAt <= now
-  return {
-    pct: expired ? null : w.pct,
-    resetMs: w.resetsAt != null && !expired ? w.resetsAt - now : null,
-    expired,
-  }
-}
-
-function ranked(map) {
-  return [...map.entries()]
-    .map(([label, tokens]) => ({ label, tokens }))
-    .sort((a, b) => b.tokens - a.tokens)
-}
-
-function getCodexUsage(now = Date.now()) {
-  if (!fs.existsSync(path.join(codexDir, 'sessions'))) return null
-  const startOfDay = new Date(now).setHours(0, 0, 0, 0)
-  const start30 = startOfDay - (DAYS - 1) * DAY
-  const files = rollouts(start30)
-  const seen = new Set()
-  let limits = null
-  let latest = null
-  let tokensToday = 0
-  let tokens5h = 0
-  let tokensWeek = 0
-  let monthTokens = 0
-  const days30 = new Array(DAYS).fill(0)
-  const byModel = new Map()
-  const byProject = new Map()
-  for (const { file, st } of files) {
-    seen.add(file)
-    const sum = readFile(file, st)
-    if (sum.limits && (!limits || sum.limits.ts > limits.ts)) limits = sum.limits
-    if (!latest || sum.mtime > latest.mtime) latest = sum
-    for (const e of sum.events) {
-      if (e.ts < start30) continue
-      monthTokens += e.tokens
-      days30[Math.min(DAYS - 1, Math.floor((e.ts - start30) / DAY))] += e.tokens
-      if (e.ts >= startOfDay) tokensToday += e.tokens
-      if (now - e.ts < 5 * 3600000) tokens5h += e.tokens
-      if (now - e.ts < WEEK) {
-        tokensWeek += e.tokens
-        const m = e.model || 'unknown'
-        byModel.set(m, (byModel.get(m) || 0) + e.tokens)
-        if (e.cwd) {
-          const p = path.basename(e.cwd)
-          byProject.set(p, (byProject.get(p) || 0) + e.tokens)
-        }
-      }
-    }
-  }
-  // forget files that aged out of the window
-  for (const f of fileCache.keys()) if (!seen.has(f)) fileCache.delete(f)
-
-  const projects = ranked(byProject)
-  const byProjectArr = projects.slice(0, TOP_PROJECTS)
-  const rest = projects.slice(TOP_PROJECTS)
-  if (rest.length) {
-    byProjectArr.push({
-      label: `other · ${rest.length}`,
-      tokens: rest.reduce((n, p) => n + p.tokens, 0),
-    })
-  }
-
-  const weeklyOnly = !!limits?.weekly && !limits.session
-  return {
-    active: !!latest && now - latest.mtime < ACTIVE_MS,
-    lastSeen: latest ? latest.mtime : null,
-    plan: limits?.plan || null,
-    // with no 5-hour window, the week is the budget that binds: it takes the
-    // session's place, the way Cursor's month does
-    session: limits ? windowNow(weeklyOnly ? limits.weekly : limits.session, now) : null,
-    weekly: limits && !weeklyOnly ? windowNow(limits.weekly, now) : null,
-    weeklyOnly,
-    limitsAt: limits?.ts || null,
-    tokensToday,
-    tokens5h,
-    tokensWeek,
-    byModel: ranked(byModel),
-    byProject: byProjectArr,
-    days30,
-    monthTokens,
-  }
-}
-
-module.exports = { getCodexUsage, detectCodex, setCodexDir }

package/config.json

@@ -1,11 +0,0 @@
-{
-  "_note": "Defaults bundled with the app. User settings are saved to ~/.claude-usage-monitor/config.json. Session/weekly % come from your account (log in via Settings).",
-  "mode": "floating",
-  "alerts": true,
-  "alertThresholds": [80, 95],
-  "fireThreshold": 90,
-  "zoom": 100,
-  "pollIntervalMs": 4000,
-  "activeThresholdMs": 20000,
-  "sleepThresholdMs": 300000
-}

package/cursor.js

@@ -1,278 +0,0 @@
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
-
-// Cursor keeps no usage in local files. Its app stores a session token in
-// `state.vscdb` (SQLite), and the same dashboard endpoints cursor.com uses
-// answer with it — unofficial, so every field is read defensively. Activity
-// comes from the agent transcripts under ~/.cursor/projects, which log each
-// tool call much like Claude Code's own logs.
-const API = 'https://api2.cursor.sh/aiserver.v1.DashboardService/'
-const ACTIVE_MS = 60000 // a transcript that says nothing counts only while it's this fresh
-// an unfinished turn this long without a write was abandoned (Cursor closed mid-run)
-const OPEN_TURN_MS = 30 * 60000
-const RECENT_TRANSCRIPTS = 8
-const FETCH_MS = 5 * 60000 // a monthly budget moves slowly; don't hammer the API
-const RETRY_MS = 60000
-const TAIL_BYTES = 64 * 1024
-
-function defaultStateDb() {
-  const tail = ['Cursor', 'User', 'globalStorage', 'state.vscdb']
-  if (process.platform === 'darwin')
-    return path.join(os.homedir(), 'Library', 'Application Support', ...tail)
-  if (process.platform === 'win32')
-    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), ...tail)
-  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), ...tail)
-}
-
-let homeDir = path.join(os.homedir(), '.cursor')
-let stateDb = defaultStateDb()
-let fetchImpl = (...args) => globalThis.fetch(...args)
-let limits = null // last good reading: { ts, plan, endMs, total, api }
-let lastTry = -Infinity
-let lastFailed = false
-let signedOut = false
-let inflight = null
-
-// tests point these elsewhere; a change of place forgets the old reading
-function configureCursor(opts = {}) {
-  if ('fetch' in opts) fetchImpl = opts.fetch || ((...args) => globalThis.fetch(...args))
-  if (!('home' in opts) && !('stateDb' in opts)) return
-  if ('home' in opts) homeDir = opts.home || path.join(os.homedir(), '.cursor')
-  if ('stateDb' in opts) stateDb = opts.stateDb || defaultStateDb()
-  limits = null
-  lastTry = -Infinity
-  lastFailed = false
-  signedOut = false
-  inflight = null
-}
-
-const text = (v) => (v == null ? null : typeof v === 'string' ? v : Buffer.from(v).toString('utf8'))
-
-// Electron's Node has `node:sqlite`; Bun, which runs the tests, has its own
-// with the same prepare/get/close
-function openReadOnly(file) {
-  try {
-    const { DatabaseSync } = require('node:sqlite')
-    return new DatabaseSync(file, { readOnly: true })
-  } catch (err) {
-    if (!process.versions.bun) throw err
-    const { Database } = require('bun:sqlite')
-    return new Database(file, { readonly: true })
-  }
-}
-
-// the app's own session: its token, plus the plan it last cached
-function readAuth() {
-  if (!fs.existsSync(stateDb)) return null
-  let db
-  try {
-    db = openReadOnly(stateDb)
-    const q = db.prepare('SELECT value FROM ItemTable WHERE key = ?')
-    const get = (k) => text(q.get(k)?.value)
-    return { token: get('cursorAuth/accessToken'), plan: get('cursorAuth/stripeMembershipType') }
-  } catch {
-    return null
-  } finally {
-    db?.close()
-  }
-}
-
-// Settings → Connect: only a signed-in app has something to read
-function detectCursor() {
-  const auth = readAuth()
-  return { found: !!auth?.token, plan: auth?.plan || null }
-}
-
-async function post(method, token) {
-  const res = await fetchImpl(API + method, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json',
-      'Connect-Protocol-Version': '1',
-    },
-    body: '{}',
-    signal: AbortSignal.timeout(15000),
-  })
-  if (!res.ok) throw new Error(`cursor ${method}: HTTP ${res.status}`)
-  return res.json()
-}
-
-const pctOf = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null)
-
-// One fetch at a time. The token is read fresh each time: the Cursor app
-// refreshes it on its own, so there is nothing to renew here.
-function refreshLimits(now = Date.now()) {
-  if (inflight) return inflight
-  lastTry = now
-  inflight = (async () => {
-    const auth = readAuth()
-    signedOut = !auth?.token
-    if (signedOut) return
-    const [usage, info] = await Promise.all([
-      post('GetCurrentPeriodUsage', auth.token),
-      post('GetPlanInfo', auth.token).catch(() => null),
-    ])
-    const pu = usage?.planUsage || {}
-    limits = {
-      ts: now,
-      plan: info?.planInfo?.planName?.toLowerCase() || auth.plan || null,
-      endMs: Number(usage?.billingCycleEnd) || null,
-      total: pctOf(pu.totalPercentUsed),
-      api: pctOf(pu.apiPercentUsed),
-    }
-  })()
-    .then(() => {
-      lastFailed = false
-    })
-    .catch((err) => {
-      lastFailed = true
-      console.error('cursor:', err.message)
-    })
-    .finally(() => {
-      inflight = null
-    })
-  return inflight
-}
-
-// the billing cycle as a window; past its end, the % belongs to the old cycle
-function cycleNow(pct, endMs, now) {
-  const expired = endMs != null && endMs <= now
-  return {
-    pct: expired ? null : pct,
-    resetMs: endMs != null && !expired ? endMs - now : null,
-    expired,
-  }
-}
-
-// ---- activity ---------------------------------------------------------------
-const ACTIVITY = {
-  Read: 'reading',
-  ReadFile: 'reading',
-  Grep: 'reading',
-  Glob: 'reading',
-  LS: 'reading',
-  ListDir: 'reading',
-  SemanticSearch: 'reading',
-  ReadLints: 'reading',
-  Write: 'editing',
-  StrReplace: 'editing',
-  Edit: 'editing',
-  MultiEdit: 'editing',
-  ApplyPatch: 'editing',
-  Delete: 'editing',
-  EditNotebook: 'editing',
-  Shell: 'running',
-  WebSearch: 'researching',
-  WebFetch: 'researching',
-  Task: 'delegating',
-  TodoWrite: 'planning',
-  CreatePlan: 'planning',
-  AskQuestion: 'waiting',
-}
-
-// what the newest transcript lines say: a finished turn means nothing is
-// running (null), an open one names its scene, and undefined means no telling
-function activityOf(lines) {
-  for (let i = lines.length - 1; i >= 0; i--) {
-    let o
-    try {
-      o = JSON.parse(lines[i])
-    } catch {
-      continue
-    }
-    if (o.type === 'turn_ended') return null
-    if (o.role === 'assistant') {
-      const blocks = Array.isArray(o.message?.content) ? o.message.content : []
-      const tool = blocks.findLast((b) => b?.type === 'tool_use')
-      return (tool && ACTIVITY[tool.name]) || 'working'
-    }
-    if (o.role === 'user') return 'working' // just asked: the agent is thinking
-  }
-  return undefined
-}
-
-const dirs = (dir) => {
-  try {
-    return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith('.'))
-  } catch {
-    return []
-  }
-}
-
-// every transcript, subagents included: projects/<p>/agent-transcripts/<id>/…
-function transcripts() {
-  const out = []
-  for (const p of dirs(path.join(homeDir, 'projects'))) {
-    if (!p.isDirectory()) continue
-    const root = path.join(homeDir, 'projects', p.name, 'agent-transcripts')
-    for (const id of dirs(root)) {
-      if (!id.isDirectory()) continue
-      const dir = path.join(root, id.name)
-      for (const f of dirs(dir)) {
-        if (f.isFile() && f.name.endsWith('.jsonl')) out.push(path.join(dir, f.name))
-        else if (f.isDirectory() && f.name === 'subagents') {
-          for (const s of dirs(path.join(dir, f.name)))
-            if (s.isFile() && s.name.endsWith('.jsonl')) out.push(path.join(dir, f.name, s.name))
-        }
-      }
-    }
-  }
-  return out
-}
-
-function tailLines(file, size) {
-  const len = Math.min(size, TAIL_BYTES)
-  const buf = Buffer.alloc(len)
-  const fd = fs.openSync(file, 'r')
-  try {
-    fs.readSync(fd, buf, 0, len, size - len)
-  } finally {
-    fs.closeSync(fd)
-  }
-  const lines = buf.toString('utf8').split('\n')
-  if (len < size) lines.shift() // cut mid-line
-  return lines.filter(Boolean)
-}
-
-// A turn stays open while a long command runs or the model thinks, without a
-// write, so an open turn in any recent transcript is Cursor at work. A
-// transcript with nothing to say counts only while it's fresh.
-function readActivity(now) {
-  const recent = []
-  let lastSeen = null
-  for (const file of transcripts()) {
-    try {
-      const st = fs.statSync(file)
-      if (lastSeen == null || st.mtimeMs > lastSeen) lastSeen = st.mtimeMs
-      if (now - st.mtimeMs < OPEN_TURN_MS) recent.push({ file, st })
-    } catch {}
-  }
-  recent.sort((a, b) => b.st.mtimeMs - a.st.mtimeMs)
-  for (const { file, st } of recent.slice(0, RECENT_TRANSCRIPTS)) {
-    let said
-    try {
-      said = activityOf(tailLines(file, st.size))
-    } catch {}
-    const activity = said === undefined ? (now - st.mtimeMs < ACTIVE_MS ? 'working' : null) : said
-    if (activity) return { active: true, activity, lastSeen }
-  }
-  return { active: false, activity: null, lastSeen }
-}
-
-// The poll's view of Cursor: activity from disk every tick, limits from the
-// last fetch (a new one starts in the background when it's due).
-function getCursorUsage(now = Date.now()) {
-  if (now - lastTry >= (limits && !lastFailed ? FETCH_MS : RETRY_MS)) refreshLimits(now)
-  return {
-    ...readActivity(now),
-    plan: limits?.plan ?? null,
-    session: limits ? cycleNow(limits.total, limits.endMs, now) : null,
-    api: limits ? cycleNow(limits.api, limits.endMs, now) : null,
-    limitsAt: limits?.ts ?? null,
-    signedOut,
-  }
-}
-
-module.exports = { getCursorUsage, refreshLimits, detectCursor, configureCursor, activityOf }