@hivefloor/cli 0.1.1 → 0.1.3

package/dist/run-BEE2ATEM.js

@@ -0,0 +1,1989 @@
+#!/usr/bin/env node
+import {
+  nudgesOf,
+  releaseSpool,
+  stashNudges,
+  takeSpool
+} from "./chunk-O2TC3WSS.js";
+import {
+  buildProfiles,
+  cliVersionOs,
+  makeEnvReader,
+  scanProcesses
+} from "./chunk-O6VSA2JT.js";
+import {
+  VERSION
+} from "./chunk-KHHSRIMU.js";
+import {
+  claudeDirsFromRc,
+  profileKeyOf,
+  profileKeys,
+  uniqueProfileKey
+} from "./chunk-E4V47VEV.js";
+import {
+  readMachine,
+  writeMachine,
+  writeServiceState
+} from "./chunk-T7TG6WA4.js";
+import {
+  apiRequest
+} from "./chunk-PY74LT2W.js";
+import {
+  configDir,
+  home,
+  isDir,
+  isRecord,
+  machineSpoolFile,
+  serviceLogFile
+} from "./chunk-VNCQFFQO.js";
+import {
+  HOOK_BATCH_MAX,
+  MACHINE_HEARTBEAT_SECONDS,
+  MACHINE_MIN_INTERVAL_SECONDS,
+  machineHeartbeatResponseSchema,
+  parseUsageKey,
+  runCmd,
+  usageReadingSchema
+} from "./chunk-TH4ANHSG.js";
+import "./chunk-K3NQKI34.js";
+
+// src/service/run.ts
+import fs2 from "fs";
+
+// src/service/collectors.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var USAGE_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var USAGE_MAX_FILES = 200;
+var USAGE_MAX_KEYS = 64;
+var CHUNK_BYTES = 64 * 1024;
+var MAX_LINE_BYTES = 2 * 1024 * 1024;
+var MAX_SEEN_IDS = 1e4;
+var SESSION_ID_RE = /^[A-Za-z0-9._:-]{1,60}$/;
+function asNonNegInt(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) return void 0;
+  return Math.floor(v);
+}
+function asPositiveCost(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) return void 0;
+  return v;
+}
+function asShortId(v) {
+  return typeof v === "string" && v.length > 0 && v.length <= 120 ? v : void 0;
+}
+function claudeProfileDirs(env, homeDir) {
+  const std = path.resolve(path.join(homeDir, ".claude"));
+  const raw = [std];
+  if (env.CLAUDE_CONFIG_DIR) raw.push(path.resolve(env.CLAUDE_CONFIG_DIR));
+  raw.push(...claudeDirsFromRc(homeDir));
+  try {
+    for (const name of fs.readdirSync(homeDir).sort()) {
+      if (!name.startsWith(".claude") || name === ".claude.json" || name.endsWith(".bak")) continue;
+      raw.push(path.resolve(path.join(homeDir, name)));
+    }
+  } catch {
+  }
+  const xdg = path.resolve(path.join(env.XDG_CONFIG_HOME || path.join(homeDir, ".config"), "claude"));
+  raw.push(xdg);
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of raw) {
+    if (seen.has(d)) continue;
+    if (d !== std && !isDir(path.join(d, "projects"))) continue;
+    seen.add(d);
+    unique.push(d);
+  }
+  return profileKeys("claude", unique, homeDir);
+}
+function codexProfileDirs(env, homeDir) {
+  const std = path.resolve(path.join(homeDir, ".codex"));
+  const raw = [std];
+  if (env.CODEX_HOME) raw.push(path.resolve(env.CODEX_HOME));
+  try {
+    for (const name of fs.readdirSync(homeDir).sort()) {
+      if (!name.startsWith(".codex") || name.endsWith(".bak")) continue;
+      raw.push(path.resolve(path.join(homeDir, name)));
+    }
+  } catch {
+  }
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of raw) {
+    if (seen.has(d)) continue;
+    if (d !== std && !isDir(path.join(d, "sessions"))) continue;
+    seen.add(d);
+    unique.push(d);
+  }
+  const map = profileKeys("codex", unique, homeDir);
+  const multi = path.join(homeDir, "Library", "Application Support", "Multi Codex", "profiles");
+  if (isDir(multi)) {
+    const used = new Set(map.values());
+    try {
+      for (const name of fs.readdirSync(multi).sort()) {
+        if (name.startsWith(".")) continue;
+        const dir = path.resolve(path.join(multi, name, "codex"));
+        if (map.has(dir) || !isDir(path.join(dir, "sessions"))) continue;
+        const key = uniqueProfileKey(profileKeyOf("codex", name, homeDir), used);
+        map.set(dir, key);
+      }
+    } catch {
+    }
+  }
+  return map;
+}
+function codexSessionFromFile(filePath) {
+  const base = path.basename(filePath, ".jsonl");
+  const stripped = base.replace(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(?:\.\d+)?-/i, "");
+  return { session: stripped, fromRollout: stripped !== base || base.startsWith("rollout") };
+}
+function collectClaudeFiles(dir, profile, cutoffMs, out) {
+  const projectsDir = path.join(dir, "projects");
+  let projects;
+  try {
+    projects = fs.readdirSync(projectsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const proj of projects) {
+    if (!proj.isDirectory()) continue;
+    const projPath = path.join(projectsDir, proj.name);
+    let entries;
+    try {
+      entries = fs.readdirSync(projPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      if (!ent.isFile() || !ent.name.endsWith(".jsonl")) continue;
+      const session = ent.name.slice(0, -6);
+      if (!SESSION_ID_RE.test(session)) continue;
+      const filePath = path.join(projPath, ent.name);
+      try {
+        const st = fs.statSync(filePath);
+        if (st.mtimeMs < cutoffMs || st.size <= 0) continue;
+        out.push({ tool: "claude", profile, session, fromRollout: false, filePath, mtimeMs: st.mtimeMs, size: st.size, ino: st.ino });
+      } catch {
+      }
+    }
+  }
+}
+function collectCodexFiles(dir, profile, cutoffMs, out) {
+  const walk = (cur, depth) => {
+    if (depth > 6) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(cur, ent.name);
+      if (ent.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (ent.isFile() && ent.name.endsWith(".jsonl")) {
+        const { session, fromRollout } = codexSessionFromFile(ent.name);
+        if (!SESSION_ID_RE.test(session)) continue;
+        try {
+          const st = fs.statSync(full);
+          if (st.mtimeMs < cutoffMs || st.size <= 0) continue;
+          out.push({ tool: "codex", profile, session, fromRollout, filePath: full, mtimeMs: st.mtimeMs, size: st.size, ino: st.ino });
+        } catch {
+        }
+      }
+    }
+  };
+  walk(path.join(dir, "sessions"), 0);
+}
+function readLinesFromOffset(filePath, startOffset, onLine) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const buf = Buffer.allocUnsafe(CHUNK_BYTES);
+    let pos = startOffset;
+    let carry = Buffer.alloc(0);
+    let tooLong = false;
+    for (; ; ) {
+      const bytesRead = fs.readSync(fd, buf, 0, CHUNK_BYTES, pos);
+      if (bytesRead <= 0) break;
+      pos += bytesRead;
+      const chunk = buf.subarray(0, bytesRead);
+      let searchFrom = 0;
+      for (; ; ) {
+        const nl = chunk.indexOf(10, searchFrom);
+        if (nl === -1) {
+          const tail = chunk.subarray(searchFrom);
+          if (!tooLong) {
+            if (carry.length + tail.length > MAX_LINE_BYTES) {
+              carry = Buffer.alloc(0);
+              tooLong = true;
+            } else if (tail.length > 0) {
+              carry = carry.length === 0 ? Buffer.from(tail) : Buffer.concat([carry, tail]);
+            }
+          }
+          break;
+        }
+        const part = chunk.subarray(searchFrom, nl);
+        searchFrom = nl + 1;
+        if (tooLong) {
+          tooLong = false;
+          carry = Buffer.alloc(0);
+          continue;
+        }
+        if (carry.length + part.length <= MAX_LINE_BYTES) {
+          const line = carry.length === 0 ? part.toString("utf8") : Buffer.concat([carry, part]).toString("utf8");
+          carry = Buffer.alloc(0);
+          onLine(line);
+        } else {
+          carry = Buffer.alloc(0);
+        }
+      }
+    }
+    if (!tooLong && carry.length > 0) {
+      const text = carry.toString("utf8").trim();
+      if (text !== "") {
+        if (!text.startsWith("{") || !text.endsWith("}") || !onLine(text)) {
+          return pos - carry.length;
+        }
+      }
+    }
+    return pos;
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+  }
+}
+function parseClaudeLine(state, line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return true;
+  if (trimmed[0] !== "{") return false;
+  if (!trimmed.includes('"usage"')) return true;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return false;
+  }
+  if (!isRecord(raw)) return true;
+  if (raw.type !== void 0 && raw.type !== "assistant") return true;
+  const msg = isRecord(raw.message) ? raw.message : void 0;
+  if (!msg) return true;
+  if (msg.role !== void 0 && msg.role !== "assistant") return true;
+  const usage = isRecord(msg.usage) ? msg.usage : void 0;
+  if (!usage) return true;
+  const msgId = asShortId(msg.id ?? msg.message_id ?? raw.message_id ?? raw.messageId);
+  if (msgId) {
+    if (state.seenIds.has(msgId)) return true;
+    if (state.seenIds.size < MAX_SEEN_IDS) state.seenIds.add(msgId);
+  }
+  const input = asNonNegInt(usage.input_tokens);
+  const cacheCreate = asNonNegInt(usage.cache_creation_input_tokens);
+  const cacheRead = asNonNegInt(usage.cache_read_input_tokens);
+  const output = asNonNegInt(usage.output_tokens);
+  if (input === void 0 && cacheCreate === void 0 && cacheRead === void 0 && output === void 0) return true;
+  state.tokensIn += (input ?? 0) + (cacheCreate ?? 0) + (cacheRead ?? 0);
+  state.tokensOut += output ?? 0;
+  state.hasUsage = true;
+  const cost = asPositiveCost(raw.costUSD ?? raw.cost_usd ?? msg.costUSD ?? msg.cost_usd ?? usage.cost_usd ?? usage.costUSD);
+  if (cost !== void 0) {
+    state.costUsd += cost;
+    state.hasCost = true;
+  }
+  return true;
+}
+function parseCodexLine(state, line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return true;
+  if (trimmed[0] !== "{") return false;
+  if (!trimmed.includes("token_count") && !trimmed.includes("session_meta")) return true;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return false;
+  }
+  if (!isRecord(raw)) return true;
+  if (raw.type === "session_meta" && state.fromRollout && isRecord(raw.payload)) {
+    const id = asShortId(raw.payload.id ?? raw.payload.session_id);
+    if (id && SESSION_ID_RE.test(id)) state.session = id;
+    return true;
+  }
+  const payload = isRecord(raw.payload) ? raw.payload : isRecord(raw.msg) ? raw.msg : void 0;
+  const ev = raw.type === "token_count" || raw.event === "token_count" ? raw : payload && (payload.type === "token_count" || payload.event === "token_count") ? payload : void 0;
+  if (!ev) return true;
+  const info = isRecord(ev.info) ? ev.info : void 0;
+  const total = (info && (isRecord(info.total_token_usage) ? info.total_token_usage : isRecord(info.total_usage) ? info.total_usage : isRecord(info.usage) ? info.usage : void 0)) ?? (isRecord(ev.total_token_usage) ? ev.total_token_usage : isRecord(ev.total_usage) ? ev.total_usage : isRecord(ev.usage) ? ev.usage : info ?? ev);
+  const tin = asNonNegInt(total.input_tokens ?? total.tokens_in ?? total.prompt_tokens);
+  const tout = asNonNegInt(total.output_tokens ?? total.tokens_out ?? total.completion_tokens);
+  if (tin === void 0 && tout === void 0) return true;
+  state.tokensIn = tin ?? 0;
+  state.tokensOut = tout ?? 0;
+  state.hasUsage = true;
+  const cost = asPositiveCost(total.cost_usd ?? total.costUSD ?? ev.cost_usd ?? ev.costUSD ?? raw.cost_usd ?? raw.costUSD);
+  if (cost !== void 0) {
+    state.costUsd = cost;
+    state.hasCost = true;
+  }
+  return true;
+}
+function createUsageCollector(opts = {}) {
+  const files = /* @__PURE__ */ new Map();
+  return () => {
+    try {
+      const homeDir = opts.homeDir ?? home();
+      const env = opts.env ?? process.env;
+      const now = opts.now ? opts.now() : Date.now();
+      const windowMs = opts.windowMs ?? USAGE_WINDOW_MS;
+      const maxFiles = opts.maxFiles ?? USAGE_MAX_FILES;
+      const maxKeys = opts.maxKeys;
+      const cutoffMs = now - windowMs;
+      const candidates = [];
+      for (const [dir, profile] of claudeProfileDirs(env, homeDir)) {
+        collectClaudeFiles(dir, profile, cutoffMs, candidates);
+      }
+      for (const [dir, profile] of codexProfileDirs(env, homeDir)) {
+        collectCodexFiles(dir, profile, cutoffMs, candidates);
+      }
+      candidates.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
+      const active = candidates.slice(0, maxFiles);
+      const activePaths = new Set(active.map((c) => c.filePath));
+      for (const k of files.keys()) {
+        if (!activePaths.has(k)) files.delete(k);
+      }
+      const usage = {};
+      const seenSessions = /* @__PURE__ */ new Set();
+      let keyCount = 0;
+      for (const c of active) {
+        let state = files.get(c.filePath);
+        if (!state || c.size < state.offset || c.ino !== 0 && state.ino !== 0 && c.ino !== state.ino) {
+          state = {
+            tool: c.tool,
+            profile: c.profile,
+            session: c.session,
+            fromRollout: c.fromRollout,
+            offset: 0,
+            size: 0,
+            mtimeMs: 0,
+            ino: c.ino,
+            tokensIn: 0,
+            tokensOut: 0,
+            costUsd: 0,
+            hasCost: false,
+            hasUsage: false,
+            seenIds: /* @__PURE__ */ new Set()
+          };
+          files.set(c.filePath, state);
+        } else {
+          state.profile = c.profile;
+        }
+        if (c.size > state.size || c.mtimeMs !== state.mtimeMs) {
+          try {
+            const parser = state.tool === "claude" ? parseClaudeLine : parseCodexLine;
+            const st = state;
+            state.offset = readLinesFromOffset(c.filePath, state.offset, (line) => parser(st, line));
+            state.size = c.size;
+            state.mtimeMs = c.mtimeMs;
+          } catch {
+            continue;
+          }
+        }
+        if (!state.hasUsage) continue;
+        const sessionKey = `${state.tool}:${state.profile}:${state.session}`;
+        if (seenSessions.has(sessionKey)) continue;
+        const base = `${state.tool}:${state.profile}:s:${state.session}`;
+        const kIn = `${base}:tokens_in`;
+        const kOut = `${base}:tokens_out`;
+        const kCost = `${base}:cost_usd`;
+        if (kIn.length > 80 || kOut.length > 80 || !parseUsageKey(kIn) || !parseUsageKey(kOut)) continue;
+        const includeCost = state.hasCost && kCost.length <= 80 && parseUsageKey(kCost) !== null;
+        const needed = includeCost ? 3 : 2;
+        if (maxKeys !== void 0 && keyCount + needed > maxKeys) continue;
+        seenSessions.add(sessionKey);
+        usage[kIn] = state.tokensIn;
+        usage[kOut] = state.tokensOut;
+        if (includeCost) usage[kCost] = Math.round(state.costUsd * 1e6) / 1e6;
+        keyCount += needed;
+      }
+      return keyCount > 0 ? { usage } : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+}
+var basics = () => {
+  const total = os.totalmem();
+  const free = os.freemem();
+  return {
+    mem_total_mb: Math.round(total / 1048576),
+    mem_pct: total > 0 ? Math.round((total - free) / total * 1e3) / 10 : void 0,
+    load1: Math.round(os.loadavg()[0] * 100) / 100
+  };
+};
+var usageCounters = createUsageCollector({ maxKeys: USAGE_MAX_KEYS });
+var collectors = [basics, usageCounters];
+async function collectStats(list = collectors) {
+  const stats = {};
+  for (const c of list) {
+    try {
+      const part = await Promise.race([Promise.resolve(c()), new Promise((r) => setTimeout(() => r(void 0), 2e3).unref())]);
+      if (part) {
+        for (const [k, v] of Object.entries(part)) {
+          if (v === void 0) continue;
+          if (k === "usage" && isRecord(v)) {
+            const merged = isRecord(stats.usage) ? { ...stats.usage } : {};
+            for (const [uk, uv] of Object.entries(v)) {
+              if (typeof uv !== "number" || !Number.isFinite(uv)) continue;
+              if (!(uk in merged) && Object.keys(merged).length >= USAGE_MAX_KEYS) break;
+              merged[uk] = uv;
+            }
+            if (Object.keys(merged).length > 0) stats.usage = merged;
+          } else {
+            stats[k] = v;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return Object.keys(stats).length > 0 ? stats : void 0;
+}
+
+// ../usage/src/machine-stats.ts
+var MB = 1024 * 1024;
+var round1 = (n) => Math.round(n * 10) / 10;
+var pct = (n) => round1(Math.min(100, Math.max(0, n)));
+async function cpuPercent(deps) {
+  const a = deps.cpuTimes();
+  await deps.sleep(300);
+  const b = deps.cpuTimes();
+  const total = b.total - a.total;
+  return total > 0 ? pct((1 - (b.idle - a.idle) / total) * 100) : 0;
+}
+function parseMeminfo(text) {
+  const get = (k) => {
+    const m = new RegExp(`^${k}:\\s+(\\d+)\\s*kB`, "m").exec(text);
+    return m ? Number(m[1]) : void 0;
+  };
+  const total = get("MemTotal");
+  const avail = get("MemAvailable");
+  if (!total || avail === void 0) return void 0;
+  return { totalMb: Math.round(total / 1024), usedMb: Math.round((total - avail) / 1024) };
+}
+function parseVmStat(text) {
+  const size = Number(/page size of (\d+) bytes/.exec(text)?.[1]);
+  const pages = (label) => {
+    const m = new RegExp(`^${label}:\\s+(\\d+)`, "m").exec(text);
+    return m ? Number(m[1]) : void 0;
+  };
+  const anon = pages("Pages anonymous");
+  const purgeable = pages("Pages purgeable") ?? 0;
+  const wired = pages("Pages wired down");
+  const compressed = pages("Pages occupied by compressor") ?? 0;
+  if (!size || anon === void 0 || wired === void 0) return void 0;
+  return { usedMb: Math.round((anon - purgeable + wired + compressed) * size / MB) };
+}
+function parseIoreg(text) {
+  const m = /"Device Utilization %"\s*=\s*(\d+)/.exec(text);
+  return m ? pct(Number(m[1])) : void 0;
+}
+function parseNvidiaSmi(text) {
+  const values = text.split("\n").map((l) => l.split(",").pop()?.trim() ?? "").filter((v) => /^\d+(\.\d+)?$/.test(v)).map(Number);
+  return values.length ? pct(Math.max(...values)) : void 0;
+}
+function parseDf(text, only) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of text.split("\n").slice(1)) {
+    const m = /^(\S+)\s+(\d+)\s+(\d+)\s+(\d+)\s+\S+\s+(\/.*)$/.exec(line.trim());
+    if (!m) continue;
+    const [, fs3, total, used, , mount] = m;
+    if (seen.has(fs3) || only && !only(fs3, mount)) continue;
+    seen.add(fs3);
+    out.push({ mount: mount.slice(0, 80), used_gb: round1(Number(used) / MB), total_gb: round1(Number(total) / MB) });
+  }
+  return out.slice(0, 8);
+}
+async function collectMachineStats(deps) {
+  const darwin = deps.platform === "darwin";
+  const cpu_pct = await cpuPercent(deps);
+  let ram_total_mb = Math.round(deps.totalmem() / MB);
+  let ram_used_mb = Math.round((deps.totalmem() - deps.freemem()) / MB);
+  if (darwin) {
+    const vm = deps.exec("vm_stat", []);
+    const parsed = vm ? parseVmStat(vm) : void 0;
+    if (parsed) ram_used_mb = parsed.usedMb;
+  } else {
+    const info = deps.readFile("/proc/meminfo");
+    const parsed = info ? parseMeminfo(info) : void 0;
+    if (parsed) {
+      ram_total_mb = parsed.totalMb;
+      ram_used_mb = parsed.usedMb;
+    }
+  }
+  ram_used_mb = Math.max(0, Math.min(ram_used_mb, ram_total_mb));
+  let gpu_pct;
+  if (darwin) {
+    const io = deps.exec("ioreg", ["-r", "-d", "1", "-w", "0", "-c", "IOAccelerator"]);
+    gpu_pct = io ? parseIoreg(io) : void 0;
+  } else {
+    const smi = deps.exec("nvidia-smi", ["--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"]);
+    gpu_pct = smi ? parseNvidiaSmi(smi) : void 0;
+  }
+  let disks = [];
+  if (darwin) {
+    const df = deps.exec("df", ["-kP", "/System/Volumes/Data"]);
+    disks = df ? parseDf(df).map((d) => ({ ...d, mount: "/" })) : [];
+  } else {
+    const df = deps.exec("df", ["-kPl"]);
+    disks = df ? parseDf(df, (fs3, mount) => fs3.startsWith("/dev/") && !fs3.startsWith("/dev/loop") && !/^\/(boot|snap|var\/lib\/docker)/.test(mount)) : [];
+  }
+  const stats = { cpu_pct, ram_used_mb, ram_total_mb, disks };
+  if (gpu_pct !== void 0) stats.gpu_pct = gpu_pct;
+  return stats;
+}
+
+// ../usage/src/readers/claude.ts
+import { createHash as createHash2 } from "crypto";
+
+// ../usage/src/util.ts
+import { createHash } from "crypto";
+function emptyOutput() {
+  return { readings: [], issues: [] };
+}
+function issue(provider, account_label, code, message) {
+  return { provider, account_label, code, message };
+}
+function asNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim() !== "") {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function asRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function clampPercent(n) {
+  return Math.round(Math.min(100, Math.max(0, n)) * 10) / 10;
+}
+function toIso(v) {
+  let ms;
+  if (typeof v === "number" && Number.isFinite(v)) ms = v < 1e11 ? v * 1e3 : v;
+  else if (typeof v === "string" && v.trim() !== "") {
+    const n = Number(v);
+    ms = Number.isFinite(n) ? n < 1e11 ? n * 1e3 : n : Date.parse(v);
+  }
+  if (ms === void 0 || !Number.isFinite(ms) || ms <= 0) return void 0;
+  const d = new Date(ms);
+  return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
+}
+function windowFromSeconds(seconds) {
+  if (seconds === void 0 || seconds <= 0) return "monthly";
+  const h = seconds / 3600;
+  if (h >= 4.5 && h <= 5.5) return "5h";
+  if (h >= 23 && h <= 25) return "daily";
+  if (h >= 6 * 24 && h <= 8 * 24) return "weekly";
+  if (h >= 27 * 24 && h <= 32 * 24) return "monthly";
+  if (h < 48) return `${Math.max(1, Math.round(h))}h`;
+  return `${Math.max(1, Math.round(h / 24))}d`;
+}
+function windowLabel(window) {
+  switch (window) {
+    case "5h":
+      return "5 hours";
+    case "daily":
+      return "Daily";
+    case "weekly":
+      return "Weekly";
+    case "monthly":
+      return "Monthly";
+    default:
+      return window;
+  }
+}
+function accountKey(provider, id) {
+  return createHash("sha256").update(`${provider}:${id}`).digest("hex").slice(0, 12);
+}
+function decodeJwt(token) {
+  const parts = token.split(".");
+  if (parts.length < 2 || !parts[1]) return void 0;
+  try {
+    const json = Buffer.from(parts[1].replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+    return asRecord(JSON.parse(json));
+  } catch {
+    return void 0;
+  }
+}
+function parseJson(text) {
+  if (text === null) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function joinPath(...parts) {
+  return parts.join("/").replace(/\/+/g, "/");
+}
+function profileName(dir, home2, base) {
+  const norm = dir.replace(/\/+$/, "");
+  const name = norm.split("/").pop() ?? "";
+  if (norm === joinPath(home2, base)) return "default";
+  const m = new RegExp(`^\\.?${base.replace(".", "")}[-_.]?(.*)$`).exec(name);
+  const rest = m?.[1];
+  const label = (rest && rest.length > 0 ? rest : name.replace(/^\./, "")).replace(/[^A-Za-z0-9._ -]/g, "").slice(0, 40);
+  return label === "" ? "default" : label;
+}
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+}
+function addWin(list, win, replace = false) {
+  const n = asNumber(win.percent);
+  if (n === void 0 || n < 0) return;
+  const next = { window: win.window, percent: clampPercent(n) };
+  if (win.label) next.label = win.label.slice(0, 60);
+  const resets = toIso(win.resets);
+  if (resets) next.resets_at = resets;
+  const i = list.findIndex((w) => w.window === win.window);
+  if (i >= 0) {
+    if (replace) list[i] = next;
+    return;
+  }
+  list.push(next);
+}
+function toReadings(provider, accountLabel, parsed, source) {
+  const label = accountLabel.slice(0, 60) || "default";
+  const key = parsed.accountId ? accountKey(provider, parsed.accountId) : void 0;
+  return parsed.windows.map((w) => {
+    const r = { provider, account_label: label, window: w.window, percent_used: w.percent, source };
+    if (key) r.account_key = key;
+    if (w.label) r.label = w.label;
+    if (w.resets_at) r.resets_at = w.resets_at;
+    if (parsed.plan) r.plan = parsed.plan.slice(0, 40);
+    return r;
+  });
+}
+function titleCase(text) {
+  return text.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function pick(r, ...keys) {
+  if (!r) return void 0;
+  for (const k of keys) if (r[k] !== void 0 && r[k] !== null) return r[k];
+  return void 0;
+}
+
+// ../usage/src/http.ts
+var ReaderError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ReaderError";
+  }
+  code;
+};
+var MESSAGES = {
+  no_login: "No login found on this machine.",
+  expired: "The login on this machine has expired. Sign in again.",
+  rejected: "The provider rejected the login. Sign in again.",
+  rate_limited: "The provider asked us to wait. Try again later.",
+  unreachable: "Could not reach the provider.",
+  bad_response: "The provider sent a response we could not read."
+};
+function issueMessage(code) {
+  return MESSAGES[code];
+}
+async function requestJson(deps, url, init = {}) {
+  let res;
+  let text;
+  try {
+    res = await deps.fetch(url, init);
+    text = await res.text();
+  } catch {
+    throw new ReaderError("unreachable", MESSAGES.unreachable);
+  }
+  if (res.status === 401 || res.status === 403) throw new ReaderError("rejected", MESSAGES.rejected);
+  if (res.status === 429) throw new ReaderError("rate_limited", MESSAGES.rate_limited);
+  if (res.status >= 500) throw new ReaderError("unreachable", MESSAGES.unreachable);
+  if (res.status < 200 || res.status >= 300) throw new ReaderError("bad_response", MESSAGES.bad_response);
+  if (/^\s*</.test(text)) throw new ReaderError("bad_response", MESSAGES.bad_response);
+  const body = parseJson(text);
+  if (body === void 0) throw new ReaderError("bad_response", MESSAGES.bad_response);
+  return body;
+}
+function failure(provider, account_label, e) {
+  const code = e instanceof ReaderError ? e.code : "bad_response";
+  return { provider, account_label, code, message: MESSAGES[code] };
+}
+async function firstOk(hosts, run) {
+  const rank = { rejected: 5, expired: 5, rate_limited: 4, bad_response: 3, unreachable: 2, no_login: 1 };
+  let best;
+  for (const host of hosts) {
+    try {
+      return await run(host);
+    } catch (e) {
+      const err = e instanceof ReaderError ? e : new ReaderError("bad_response", MESSAGES.bad_response);
+      if (!best || rank[err.code] > rank[best.code]) best = err;
+    }
+  }
+  throw best ?? new ReaderError("unreachable", MESSAGES.unreachable);
+}
+
+// ../usage/src/readers/claude.ts
+var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
+var SERVICE = "Claude Code-credentials";
+var RC_FILES = [".zshrc", ".zprofile", ".bashrc", ".bash_profile", ".profile", ".config/fish/config.fish"];
+function normalizeDir(dir) {
+  const d = dir.trim();
+  if (!d.startsWith("/")) return d.replace(/\/+$/, "");
+  const out = [];
+  for (const seg of d.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return "/" + out.join("/");
+}
+function claudeConfigDirs(deps) {
+  const dirs = [];
+  const add = (d) => {
+    if (!d) return;
+    const norm = normalizeDir(d);
+    if (norm && !dirs.includes(norm)) dirs.push(norm);
+  };
+  add(deps.env.CLAUDE_CONFIG_DIR);
+  add(joinPath(deps.home, ".claude"));
+  for (const name of deps.readDir(deps.home).sort()) {
+    if (/^\.claude-[A-Za-z0-9._-]+$/.test(name)) add(joinPath(deps.home, name));
+  }
+  add(joinPath(deps.env.XDG_CONFIG_HOME ?? joinPath(deps.home, ".config"), "claude"));
+  for (const rc of RC_FILES) {
+    const text = deps.readFile(joinPath(deps.home, rc));
+    if (!text) continue;
+    for (const line of text.split("\n")) {
+      if (/^\s*#/.test(line)) continue;
+      for (const m of line.matchAll(/CLAUDE_CONFIG_DIR=(?:"([^"\n]+)"|'([^'\n]+)'|([^\s"';|&]+))/g)) {
+        const raw = m[1] ?? m[2] ?? m[3] ?? "";
+        const expanded = raw.replace(/^~(?=\/|$)/, deps.home).replace(/^\$\{?HOME\}?/, deps.home);
+        if (expanded.startsWith("/") && !expanded.includes("$")) add(expanded);
+      }
+    }
+  }
+  return dirs;
+}
+function parseClaudeCreds(raw, now) {
+  const auth = asRecord(asRecord(parseJson(raw))?.claudeAiOauth);
+  const token = asString(auth?.accessToken);
+  if (!auth || !token) return { kind: "none" };
+  const scopes = Array.isArray(auth.scopes) ? auth.scopes.filter((s) => typeof s === "string") : String(auth.scopes ?? "").split(/\s+/).filter(Boolean);
+  if (scopes.length > 0 && !scopes.includes("user:profile")) return { kind: "no_scope" };
+  const exp = asNumber(auth.expiresAt);
+  if (exp !== void 0 && exp > 0 && exp <= now) return { kind: "expired" };
+  return { kind: "ok", token, plan: planName(asString(auth.subscriptionType)) };
+}
+function planName(raw) {
+  const v = (raw ?? "").toLowerCase();
+  if (v.includes("enterprise")) return "Enterprise";
+  if (v.includes("team")) return "Team";
+  if (v.includes("max")) return "Max";
+  if (v.includes("pro")) return "Pro";
+  if (v.includes("free")) return "Free";
+  return void 0;
+}
+function resetOf(b) {
+  return b.resets_at ?? b.resetsAt;
+}
+function parseClaudeUsage(json) {
+  const src = asRecord(json) ?? {};
+  const windows = [];
+  const five = asRecord(src.five_hour ?? src.fiveHour);
+  if (five) addWin(windows, { window: "5h", label: "5 hours", percent: five.utilization ?? five.used_percent, resets: resetOf(five) });
+  const week = asRecord(src.seven_day ?? src.sevenDay);
+  if (week) addWin(windows, { window: "weekly", label: "Weekly", percent: week.utilization ?? week.used_percent, resets: resetOf(week) });
+  const named = [
+    ["seven_day_sonnet", "weekly:sonnet", "Sonnet weekly"],
+    ["seven_day_opus", "weekly:opus", "Opus weekly"],
+    ["seven_day_oauth_apps", "weekly:apps", "Apps weekly"],
+    ["seven_day_cowork", "weekly:cowork", "Cowork weekly"]
+  ];
+  for (const [key, window, label] of named) {
+    const b = asRecord(src[key]);
+    if (!b || asNumber(b.utilization) === void 0) continue;
+    if (b.utilization === 0 && !resetOf(b)) continue;
+    addWin(windows, { window, label, percent: b.utilization, resets: resetOf(b) });
+  }
+  const limits = Array.isArray(src.limits) ? src.limits : Array.isArray(asRecord(src.rate_limits)?.limits) ? asRecord(src.rate_limits)?.limits : [];
+  for (const raw of limits) {
+    const item = asRecord(raw);
+    if (!item) continue;
+    const kind = String(item.kind ?? item.group ?? "").toLowerCase();
+    const model = asString(asRecord(asRecord(item.scope)?.model)?.display_name);
+    let window;
+    let label;
+    if (kind === "session" || kind === "five_hour") {
+      window = "5h";
+      label = "5 hours";
+    } else if (model) {
+      window = `weekly:${slug(model)}`;
+      label = `${model} weekly`;
+    } else if (["weekly", "weekly_all", "seven_day", "weekly_scoped"].includes(kind)) {
+      window = "weekly";
+      label = "Weekly";
+    } else {
+      continue;
+    }
+    addWin(windows, { window, label, percent: item.percent ?? item.used_percent ?? item.usedPercent ?? item.utilization, resets: resetOf(item) }, item.is_active === true);
+  }
+  const extra = asRecord(src.extra_usage ?? src.extraUsage);
+  if (extra) {
+    const used = asNumber(extra.used_credits);
+    const limit = asNumber(extra.monthly_limit);
+    const pct2 = asNumber(extra.utilization) ?? (used !== void 0 && limit ? used / limit * 100 : void 0);
+    if (pct2 !== void 0 && (extra.is_enabled === true || limit !== void 0)) addWin(windows, { window: "monthly:extra", label: "Extra usage", percent: pct2 });
+  }
+  return { windows };
+}
+function keychainService(dir, home2) {
+  if (dir === joinPath(home2, ".claude")) return SERVICE;
+  return `${SERVICE}-${createHash2("sha256").update(dir).digest("hex").slice(0, 8)}`;
+}
+var readClaude = async (deps) => {
+  const out = emptyOutput();
+  const seenTokens = /* @__PURE__ */ new Set();
+  const seenLabels = /* @__PURE__ */ new Set();
+  const readLabels = /* @__PURE__ */ new Set();
+  for (const dir of claudeConfigDirs(deps)) {
+    let raw = deps.readFile(joinPath(dir, ".credentials.json"));
+    if (raw === null && deps.platform === "darwin" && deps.exec) {
+      raw = deps.exec("security", ["find-generic-password", "-s", keychainService(dir, deps.home), "-w"]);
+    }
+    if (raw === null) continue;
+    const base = profileName(dir, deps.home, ".claude").slice(0, 60);
+    let label = base;
+    for (let n = 2; seenLabels.has(label); n++) {
+      const suffix = `-${n}`;
+      label = `${base.slice(0, 60 - suffix.length)}${suffix}`;
+    }
+    const creds = parseClaudeCreds(raw, deps.now());
+    if (creds.kind === "none") continue;
+    seenLabels.add(label);
+    if (creds.kind === "expired") {
+      out.issues.push(issue("claude", label, "expired", "The saved login is out of date (no Claude session used it lately). It updates the next time Claude Code runs on this profile."));
+      continue;
+    }
+    if (creds.kind === "no_scope") {
+      out.issues.push(issue("claude", label, "rejected", "This login cannot show usage (no profile scope). Sign in with the browser."));
+      continue;
+    }
+    if (seenTokens.has(creds.token)) continue;
+    seenTokens.add(creds.token);
+    try {
+      const parsed = await readTokenUsage(deps, creds.token);
+      parsed.plan ??= creds.plan;
+      out.readings.push(...toReadings("claude", label, parsed, "local_login"));
+      readLabels.add(label);
+    } catch (e) {
+      out.issues.push(failure("claude", label, e));
+    }
+  }
+  await readNamedTokens(deps, seenTokens, readLabels, out);
+  await readEnvTokens(deps, seenTokens, out);
+  return out;
+};
+var CLAUDE_HEADERS = (token) => ({
+  Authorization: `Bearer ${token}`,
+  "anthropic-beta": "oauth-2025-04-20",
+  "anthropic-version": "2023-06-01",
+  Accept: "application/json"
+});
+async function readTokenUsage(deps, token) {
+  const headers = CLAUDE_HEADERS(token);
+  let parsed;
+  try {
+    parsed = parseClaudeUsage(await requestJson(deps, USAGE_URL, { headers }));
+    if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+  } catch (e) {
+    if (!(e instanceof ReaderError) || e.code !== "rejected" && e.code !== "rate_limited") throw e;
+    return probeRateLimits(deps, token);
+  }
+  try {
+    const profile = asRecord(await requestJson(deps, PROFILE_URL, { headers }));
+    const account = asRecord(profile?.account) ?? profile;
+    parsed.accountId = asString(account?.uuid) ?? asString(account?.id);
+    const org = asRecord(profile?.organization);
+    parsed.plan ??= planName(asString(org?.organization_type) ?? asString(org?.rate_limit_tier));
+  } catch {
+  }
+  return parsed;
+}
+var PROBE_URL = "https://api.anthropic.com/v1/messages";
+var PROBE_MODEL = "claude-haiku-5-5";
+var PROBE_TTL_MS = 15 * 6e4;
+var probeCache = /* @__PURE__ */ new Map();
+function parseClaudeRateHeaders(h) {
+  const windows = [];
+  const names = {
+    "5h": ["5h", "5 hours"],
+    "7d": ["weekly", "Weekly"],
+    "7d_opus": ["weekly:opus", "Opus weekly"],
+    "7d_sonnet": ["weekly:sonnet", "Sonnet weekly"]
+  };
+  for (const [key, value] of Object.entries(h)) {
+    const m = /^anthropic-ratelimit-unified-([a-z0-9_]+)-utilization$/.exec(key.toLowerCase());
+    if (!m) continue;
+    const id = m[1];
+    const util = asNumber(Number(value));
+    if (util === void 0) continue;
+    const [window, label] = names[id] ?? (/^7d_[a-z0-9]+$/.test(id) ? [`weekly:${slug(id.slice(3))}`, `${id.slice(3)} weekly`] : [`${slug(id)}`, id]);
+    if (!/^[a-z0-9]+(?::[a-z0-9._-]+)?$/.test(window)) continue;
+    addWin(windows, { window, label, percent: util * 100, resets: h[`anthropic-ratelimit-unified-${id}-reset`] });
+  }
+  windows.sort((a, b) => a.window === "5h" ? -1 : b.window === "5h" ? 1 : a.window.localeCompare(b.window));
+  return { windows };
+}
+async function probeRateLimits(deps, token) {
+  const key = tokenLabel(token);
+  const cached = probeCache.get(key);
+  if (cached && deps.now() - cached.at < PROBE_TTL_MS) return { ...cached.parsed, windows: [...cached.parsed.windows] };
+  const model = /^[a-z0-9.-]{3,60}$/.test(deps.env.HIVEFLOOR_CLAUDE_PROBE_MODEL ?? "") ? deps.env.HIVEFLOOR_CLAUDE_PROBE_MODEL : PROBE_MODEL;
+  let res;
+  try {
+    res = await deps.fetch(PROBE_URL, {
+      method: "POST",
+      headers: { ...CLAUDE_HEADERS(token), "content-type": "application/json" },
+      body: JSON.stringify({
+        model,
+        max_tokens: 1,
+        system: "You are Claude Code, Anthropic's official CLI for Claude.",
+        messages: [{ role: "user", content: "hi" }]
+      })
+    });
+    await res.text();
+  } catch {
+    throw new ReaderError("unreachable", issueMessage("unreachable"));
+  }
+  const parsed = parseClaudeRateHeaders(res.headers ?? {});
+  if (parsed.windows.length > 0) {
+    probeCache.set(key, { at: deps.now(), parsed });
+    return parsed;
+  }
+  if (res.status === 401 || res.status === 403) throw new ReaderError("rejected", issueMessage("rejected"));
+  if (res.status === 429) throw new ReaderError("rate_limited", issueMessage("rate_limited"));
+  if (res.status >= 500) throw new ReaderError("unreachable", issueMessage("unreachable"));
+  throw new ReaderError("bad_response", issueMessage("bad_response"));
+}
+var MAX_SESSION_TOKENS = 20;
+var NAME_RE = /^[A-Za-z0-9._-]{1,40}$/;
+var tokenLabel = (token) => `token-${createHash2("sha256").update(token).digest("hex").slice(0, 6)}`;
+function claudeTokenProfiles(deps) {
+  const names = /* @__PURE__ */ new Set();
+  const add = (n) => {
+    if (NAME_RE.test(n) && n !== "api") names.add(n);
+  };
+  for (const f of deps.readDir(joinPath(deps.home, ".config/fleet-cc")).sort()) {
+    const m = /^(.+)\.token$/.exec(f);
+    if (m) add(m[1]);
+  }
+  for (const d of deps.readDir(deps.home).sort()) {
+    const m = /^\.claude-([A-Za-z0-9._-]+)$/.exec(d);
+    if (m) add(m[1]);
+  }
+  const cc = deps.readFile(joinPath(deps.home, ".claude/fleet/cc.sh"));
+  const line = cc ? /^PROFILES="([^"\n]*)"/m.exec(cc) : null;
+  for (const n of (line?.[1] ?? "").split(/\s+/)) if (n) add(n);
+  for (const n of (deps.env.HIVEFLOOR_CLAUDE_PROFILES ?? "").split(/[\s,]+/)) if (n) add(n);
+  return [...names];
+}
+function namedToken(deps, name) {
+  let t = deps.readFile(joinPath(deps.home, `.config/fleet-cc/${name}.token`));
+  if ((t === null || t.trim() === "") && deps.platform === "darwin" && deps.exec) {
+    t = deps.exec("security", ["find-generic-password", "-s", `fleet-cc-${name}`, "-w"]);
+  }
+  const v = t?.trim() ?? "";
+  return /^[\w.~+/=-]{20,400}$/.test(v) ? v : null;
+}
+async function readNamedTokens(deps, seenTokens, readLabels, out) {
+  for (const name of claudeTokenProfiles(deps)) {
+    if (readLabels.has(name)) continue;
+    const token = namedToken(deps, name);
+    if (!token || seenTokens.has(token)) continue;
+    seenTokens.add(token);
+    try {
+      const parsed = await readTokenUsage(deps, token);
+      out.readings.push(...toReadings("claude", name, parsed, "local_login"));
+      readLabels.add(name);
+      out.issues = out.issues.filter((i) => !(i.provider === "claude" && i.account_label === name));
+    } catch (e) {
+      if (!out.issues.some((i) => i.provider === "claude" && i.account_label === name)) out.issues.push(failure("claude", name, e));
+    }
+  }
+}
+async function readEnvTokens(deps, seenTokens, out) {
+  const tokens = [...new Set(deps.claudeTokens ?? [])].filter((t) => t.length >= 20 && !seenTokens.has(t)).slice(0, MAX_SESSION_TOKENS);
+  let blind = 0;
+  for (const token of tokens) {
+    seenTokens.add(token);
+    const label = tokenLabel(token);
+    try {
+      const parsed = await readTokenUsage(deps, token);
+      out.readings.push(...toReadings("claude", label, parsed, "env_key"));
+    } catch (e) {
+      if (e instanceof ReaderError && e.code === "rejected") blind++;
+      else out.issues.push(failure("claude", label, e));
+    }
+  }
+  if (blind > 0) {
+    out.issues.push(
+      issue(
+        "claude",
+        "session tokens",
+        "rejected",
+        `${blind} session token${blind === 1 ? "" : "s"} (CLAUDE_CODE_OAUTH_TOKEN) cannot read usage, so those accounts can't be told apart here. Log each in with /login.`
+      )
+    );
+  }
+}
+
+// ../usage/src/readers/codex.ts
+var USAGE_URL2 = "https://chatgpt.com/backend-api/wham/usage";
+function codexDirs(deps) {
+  const dirs = [];
+  const add = (dir, label) => {
+    if (dir && !dirs.some((d) => d.dir === dir)) dirs.push({ dir: dir.replace(/\/+$/, ""), label });
+  };
+  add(deps.env.CODEX_HOME, "default");
+  add(joinPath(deps.home, ".codex"), "default");
+  if (deps.platform === "darwin") {
+    const profiles = joinPath(deps.home, "Library", "Application Support", "Multi Codex", "profiles");
+    for (const name of deps.readDir(profiles).sort()) {
+      if (!name.startsWith(".")) add(joinPath(profiles, name, "codex"), name.slice(0, 40));
+    }
+  }
+  return dirs;
+}
+function parseCodexCreds(raw, now) {
+  const data = asRecord(parseJson(raw));
+  if (!data) return { kind: "none" };
+  const tokens = asRecord(data.tokens) ?? data;
+  const token = asString(tokens.access_token) ?? asString(data.access_token);
+  if (!token) return asString(data.OPENAI_API_KEY) ? { kind: "api_key" } : { kind: "none" };
+  const payload = decodeJwt(token);
+  const exp = asNumber(payload?.exp);
+  if (exp !== void 0 && exp > 0 && exp * 1e3 <= now) return { kind: "expired" };
+  const auth = asRecord(payload?.["https://api.openai.com/auth"]);
+  return { kind: "ok", token, accountId: asString(tokens.account_id) ?? asString(data.account_id) ?? asString(auth?.chatgpt_account_id) };
+}
+function windowOf(slot, fallback, suffix, resetsFallback) {
+  const w = asRecord(slot);
+  if (!w) return void 0;
+  const seconds = asNumber(w.limit_window_seconds ?? w.limitWindowSeconds ?? w.window_seconds);
+  const base = seconds === void 0 ? fallback : windowFromSeconds(seconds);
+  return {
+    window: suffix ? `${base}:${suffix.id}` : base,
+    label: suffix ? `${suffix.name} ${windowLabel(base)}` : windowLabel(base),
+    percent: w.used_percent ?? w.usedPercent,
+    resets: w.reset_at ?? w.resetAt ?? w.resets_at ?? w.resetsAt ?? resetsFallback
+  };
+}
+function parseCodexUsage(json) {
+  const src = asRecord(json) ?? {};
+  const rate = asRecord(src.rate_limit ?? src.rateLimit) ?? src;
+  const windows = [];
+  const addRate = (r, suffix) => {
+    for (const [slot, fallback] of [["primary", "5h"], ["secondary", "weekly"]]) {
+      const w = windowOf(r[`${slot}_window`] ?? r[`${slot}Window`] ?? r[slot], fallback, suffix);
+      if (w) addWin(windows, w);
+    }
+  };
+  addRate(rate);
+  const review = asRecord(src.code_review_rate_limit ?? src.codeReviewRateLimit);
+  if (review) addRate(review, { id: "code-review", name: "Code review" });
+  const more = src.additional_rate_limits ?? src.additionalRateLimits;
+  if (Array.isArray(more)) {
+    for (const raw of more) {
+      const item = asRecord(raw);
+      const name = asString(item?.limit_name ?? item?.limitName ?? item?.metered_feature ?? item?.meteredFeature);
+      const r = asRecord(item?.rate_limit ?? item?.rateLimit);
+      if (name && r) addRate(r, { id: slug(name) || "extra", name });
+    }
+  }
+  const plan = asString(src.plan_type ?? src.planType ?? rate.plan_type);
+  return { windows, plan: plan ? titleCase(plan) : void 0 };
+}
+var readCodex = async (deps) => {
+  const out = emptyOutput();
+  const seen = /* @__PURE__ */ new Set();
+  for (const { dir, label } of codexDirs(deps)) {
+    const raw = deps.readFile(joinPath(dir, "auth.json"));
+    if (raw === null) continue;
+    const creds = parseCodexCreds(raw, deps.now());
+    if (creds.kind === "none") continue;
+    if (creds.kind === "expired") {
+      out.issues.push(issue("codex", label, "expired", issueMessage("expired")));
+      continue;
+    }
+    if (creds.kind === "api_key") {
+      out.issues.push(issue("codex", label, "no_login", "Signed in with an API key, which has no plan usage to show."));
+      continue;
+    }
+    const id = creds.accountId ?? creds.token;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const headers = { Authorization: `Bearer ${creds.token}`, Accept: "application/json" };
+    if (creds.accountId) headers["ChatGPT-Account-Id"] = creds.accountId;
+    try {
+      const parsed = parseCodexUsage(await requestJson(deps, USAGE_URL2, { headers }));
+      if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+      if (creds.accountId) parsed.accountId = creds.accountId;
+      out.readings.push(...toReadings("codex", label, parsed, "local_login"));
+    } catch (e) {
+      out.issues.push(failure("codex", label, e));
+    }
+  }
+  return out;
+};
+
+// ../usage/src/readers/copilot.ts
+var URL_ = "https://api.github.com/copilot_internal/user";
+var QUALIFIER = {
+  premium_interactions: ["monthly", "Premium requests"],
+  chat: ["monthly:chat", "Chat"],
+  completions: ["monthly:completions", "Completions"]
+};
+function findCopilotToken(files) {
+  for (const raw of files) {
+    const data = asRecord(parseJson(raw));
+    if (!data) continue;
+    for (const [key, value] of Object.entries(data)) {
+      if (!/github\.com/.test(key)) continue;
+      const token = asString(asRecord(value)?.oauth_token);
+      if (token) return token;
+    }
+  }
+  return void 0;
+}
+function parseCopilotUsage(json) {
+  const src = asRecord(json) ?? {};
+  const snaps = asRecord(src.quota_snapshots ?? src.quotaSnapshots) ?? {};
+  const resets = src.quota_reset_date_utc ?? src.quotaResetDateUtc ?? src.quota_reset_date ?? src.quotaResetDate;
+  const windows = [];
+  for (const [key, raw] of Object.entries(snaps)) {
+    const row = asRecord(raw);
+    if (!row || row.unlimited === true) continue;
+    const remaining = asNumber(row.percent_remaining ?? row.percentRemaining);
+    const entitlement = asNumber(row.entitlement ?? row.limit);
+    const left = asNumber(row.remaining ?? row.remaining_count);
+    let used = remaining === void 0 ? void 0 : 100 - Math.min(100, Math.max(0, remaining));
+    if (used === void 0 && entitlement && entitlement > 0 && left !== void 0) used = (entitlement - left) / entitlement * 100;
+    if (used === void 0) continue;
+    const [window, label] = QUALIFIER[key] ?? [`monthly:${key.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 24)}`, titleCase(key)];
+    addWin(windows, { window, label, percent: used, resets: row.quota_reset_at ?? row.quotaResetAt ?? resets });
+  }
+  const plan = asString(src.copilot_plan ?? src.copilotPlan);
+  return { windows, plan: plan ? titleCase(plan) : void 0, accountId: asString(src.login) };
+}
+var readCopilot = async (deps) => {
+  const out = emptyOutput();
+  const dir = joinPath(deps.env.XDG_CONFIG_HOME ?? joinPath(deps.home, ".config"), "github-copilot");
+  const token = findCopilotToken([deps.readFile(joinPath(dir, "apps.json")), deps.readFile(joinPath(dir, "hosts.json"))]);
+  if (!token) return out;
+  const headers = {
+    Accept: "application/json",
+    Authorization: `token ${token}`,
+    "Editor-Version": "vscode/1.96.2",
+    "Editor-Plugin-Version": "copilot-chat/0.26.7",
+    "User-Agent": "GitHubCopilotChat/0.26.7",
+    "X-Github-Api-Version": "2025-04-01"
+  };
+  try {
+    const parsed = parseCopilotUsage(await requestJson(deps, URL_, { headers }));
+    if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+    out.readings.push(...toReadings("copilot", "default", parsed, "local_login"));
+  } catch (e) {
+    out.issues.push(failure("copilot", "default", e));
+  }
+  return out;
+};
+
+// ../usage/src/readers/cursor.ts
+var SUMMARY_URL = "https://cursor.com/api/usage-summary";
+function parseCursorCreds(raw, now) {
+  const text = (raw ?? "").trim();
+  if (!text) return { kind: "none" };
+  const data = text.startsWith("{") ? asRecord(parseJson(text)) : void 0;
+  const token = (data ? asString(data.accessToken ?? data.access_token) : text)?.replace(/^['"]|['"]$/g, "");
+  if (!token) return { kind: "none" };
+  const payload = decodeJwt(token);
+  const exp = asNumber(payload?.exp);
+  if (exp !== void 0 && exp > 0 && exp * 1e3 <= now) return { kind: "expired" };
+  const sub = String(payload?.sub ?? "").split("|").filter(Boolean).pop();
+  return { kind: "ok", token, userId: sub };
+}
+var PLANS = { free: "Free", pro: "Pro", pro_plus: "Pro+", ultra: "Ultra", business: "Business", enterprise: "Enterprise", free_trial: "Trial" };
+function cents(block) {
+  const b = asRecord(block);
+  if (!b || b.enabled === false) return void 0;
+  const used = asNumber(b.used);
+  let limit = asNumber(b.limit);
+  const remaining = asNumber(b.remaining);
+  if (!(limit && limit > 0) && used !== void 0 && remaining !== void 0) limit = used + remaining;
+  return used !== void 0 && limit && limit > 0 ? used / limit * 100 : void 0;
+}
+function parseCursorSummary(json) {
+  const src = asRecord(json) ?? {};
+  const end = toIso(src.billingCycleEnd);
+  const start = toIso(src.billingCycleStart);
+  const seconds = start && end ? (Date.parse(end) - Date.parse(start)) / 1e3 : void 0;
+  const base = seconds && seconds > 0 ? windowFromSeconds(seconds) : "monthly";
+  const individual = asRecord(src.individualUsage ?? src.individual_usage) ?? {};
+  const team = asRecord(src.teamUsage ?? src.team_usage) ?? {};
+  const plan = asRecord(individual.plan) ?? {};
+  const windows = [];
+  if (src.isUnlimited === true) {
+    addWin(windows, { window: base, label: "Plan (unlimited)", percent: 0, resets: end });
+  } else {
+    const auto = asNumber(plan.autoPercentUsed);
+    const api = asNumber(plan.apiPercentUsed);
+    const total = asNumber(plan.totalPercentUsed);
+    if (auto !== void 0) addWin(windows, { window: `${base}:cursor-models`, label: "Cursor models", percent: auto, resets: end });
+    if (api !== void 0) addWin(windows, { window: `${base}:other-models`, label: "Other models", percent: api, resets: end });
+    if (auto === void 0 && api === void 0) {
+      const pct2 = total ?? cents(plan) ?? cents(individual) ?? cents(individual.overall);
+      if (pct2 !== void 0) addWin(windows, { window: base, label: "Plan", percent: pct2, resets: end });
+    }
+  }
+  const onDemand = cents(individual.onDemand ?? individual.on_demand);
+  if (onDemand !== void 0) addWin(windows, { window: `${base}:on-demand`, label: "On-demand", percent: onDemand, resets: end });
+  const pool = cents(team.pooled) ?? cents(team);
+  if (pool !== void 0) addWin(windows, { window: `${base}:team-pool`, label: "Team pool", percent: pool, resets: end });
+  const type = String(src.membershipType ?? "").trim().toLowerCase();
+  return { windows, plan: type ? PLANS[type] ?? titleCase(type) : void 0 };
+}
+var readCursor = async (deps) => {
+  const out = emptyOutput();
+  let raw = null;
+  if (deps.platform === "darwin" && deps.exec) {
+    raw = deps.exec("security", ["find-generic-password", "-s", "cursor-access-token", "-w"]);
+  }
+  raw ??= deps.readFile(joinPath(deps.env.XDG_CONFIG_HOME ?? joinPath(deps.home, ".config"), "cursor", "auth.json"));
+  if (raw === null) return out;
+  const creds = parseCursorCreds(raw, deps.now());
+  if (creds.kind === "none") return out;
+  if (creds.kind === "expired") {
+    out.issues.push(issue("cursor", "default", "expired", issueMessage("expired")));
+    return out;
+  }
+  const headers = { Accept: "application/json", Origin: "https://cursor.com", Referer: "https://cursor.com/dashboard" };
+  if (creds.userId) headers.Cookie = `WorkosCursorSessionToken=${creds.userId}%3A%3A${creds.token}`;
+  else headers.Authorization = `Bearer ${creds.token}`;
+  try {
+    const parsed = parseCursorSummary(await requestJson(deps, SUMMARY_URL, { headers }));
+    if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+    parsed.accountId = creds.userId;
+    out.readings.push(...toReadings("cursor", "default", parsed, "local_login"));
+  } catch (e) {
+    out.issues.push(failure("cursor", "default", e));
+  }
+  return out;
+};
+
+// ../usage/src/readers/gemini.ts
+var BASE = "https://cloudcode-pa.googleapis.com/v1internal";
+function parseGeminiCreds(raw) {
+  const data = asRecord(parseJson(raw));
+  if (!data) return void 0;
+  const t = asRecord(data.token) ?? data;
+  const token = asString(t.access_token ?? t.accessToken);
+  return token ? { token } : void 0;
+}
+function project(v) {
+  return asString(v)?.trim() ?? asString(asRecord(v)?.id);
+}
+function fraction(b) {
+  const nested = asRecord(b.remaining) ?? {};
+  const r = asNumber(b.remainingFraction ?? b.remaining_fraction ?? nested.remainingFraction ?? nested.remaining_fraction);
+  if (r === void 0) return void 0;
+  return Math.min(1, Math.max(0, r > 1 ? r / 100 : r));
+}
+function parseGeminiSummary(json) {
+  const src = asRecord(json) ?? {};
+  let groups = Array.isArray(src.groups) ? src.groups : [];
+  if (groups.length === 0 && Array.isArray(src.buckets)) {
+    groups = [{ buckets: src.buckets.filter((b) => b && typeof b === "object" && !asRecord(b)?.modelId && !asRecord(b)?.model_id) }];
+  }
+  const windows = [];
+  for (const g of groups) {
+    const group = asRecord(g);
+    if (!group) continue;
+    const name = (asString(group.displayName ?? group.display_name) ?? "").replace(/\s+models?$/i, "").replace(/\s+and\s+/gi, " & ").trim();
+    const buckets = Array.isArray(group.buckets) ? group.buckets : [];
+    for (const raw of buckets) {
+      const b = asRecord(raw);
+      if (!b || b.disabled === true) continue;
+      const f = fraction(b);
+      if (f === void 0) continue;
+      const id = String(b.bucketId ?? b.bucket_id ?? "");
+      const kind = String(b.window ?? "");
+      const base = kind === "weekly" || /weekly/i.test(id) ? "weekly" : kind === "5h" || /-5h\b/i.test(id) ? "5h" : void 0;
+      if (!base) continue;
+      const q = slug(name);
+      addWin(windows, {
+        window: q ? `${base}:${q}` : base,
+        label: `${name ? `${name} ` : ""}${base === "weekly" ? "weekly" : "5 hours"}`,
+        percent: (1 - f) * 100,
+        resets: b.resetTime ?? b.reset_time
+      });
+    }
+  }
+  return { windows };
+}
+var readGemini = async (deps) => {
+  const out = emptyOutput();
+  const raw = deps.readFile(joinPath(deps.home, ".gemini", "antigravity-cli", "antigravity-oauth-token"));
+  if (raw === null) return out;
+  const creds = parseGeminiCreds(raw);
+  if (!creds) return out;
+  const headers = { Authorization: `Bearer ${creds.token}`, "Content-Type": "application/json", Accept: "application/json" };
+  const post = (method, body) => requestJson(deps, `${BASE}:${method}`, { method: "POST", headers, body: JSON.stringify(body) });
+  try {
+    const loaded = asRecord(await post("loadCodeAssist", { metadata: { ideType: "IDE_UNSPECIFIED", pluginType: "GEMINI" } })) ?? {};
+    const proj = project(loaded.cloudaicompanionProject ?? loaded.cloudaicompanion_project);
+    if (!proj) throw new ReaderError("bad_response", issueMessage("bad_response"));
+    const parsed = parseGeminiSummary(await post("retrieveUserQuotaSummary", { project: proj }));
+    const tier = asString(asRecord(loaded.currentTier ?? loaded.current_tier)?.name);
+    if (tier) parsed.plan = titleCase(tier);
+    if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+    out.readings.push(...toReadings("gemini", "default", parsed, "local_login"));
+  } catch (e) {
+    out.issues.push(failure("gemini", "default", e));
+  }
+  return out;
+};
+
+// ../usage/src/readers/grok.ts
+var BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+var SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+function extractGrokAuth(data) {
+  const found = [];
+  const walk = (node, depth) => {
+    if (depth > 6) return;
+    if (Array.isArray(node)) {
+      for (const v of node) walk(v, depth + 1);
+      return;
+    }
+    const r = asRecord(node);
+    if (!r) return;
+    if (typeof r.key === "string" && r.key.length > 20) found.push({ token: r.key, expiresAt: r.expires_at ?? r.expiresAt });
+    for (const v of Object.values(r)) if (v && typeof v === "object") walk(v, depth + 1);
+  };
+  walk(data, 0);
+  const seen = /* @__PURE__ */ new Set();
+  return found.filter((e) => seen.has(e.token) ? false : (seen.add(e.token), true));
+}
+function percent(v) {
+  const n = asNumber(v);
+  return n === void 0 || n < 0 ? void 0 : n;
+}
+function parseGrokBilling(json) {
+  const src = asRecord(json) ?? {};
+  const config = asRecord(src.config) ?? src;
+  let used = percent(config.creditUsagePercent ?? config.credit_usage_percent ?? config.usedPercent ?? config.usagePercent);
+  if (used === void 0) {
+    const usage = asRecord(src.usage ?? config.usage);
+    const u = asNumber(asRecord(usage?.totalUsed)?.val ?? usage?.totalUsed);
+    const limit = asNumber(asRecord(src.monthlyLimit)?.val ?? asRecord(config.monthlyLimit)?.val ?? config.monthlyLimit);
+    if (u !== void 0 && limit) used = u / limit * 100;
+  }
+  const period = asRecord(config.currentPeriod ?? config.current_period ?? src.billingCycle) ?? {};
+  const start = toIso(period.start ?? period.billingPeriodStart ?? config.billingPeriodStart);
+  const end = toIso(period.end ?? period.billingPeriodEnd ?? config.billingPeriodEnd);
+  const seconds = start && end ? (Date.parse(end) - Date.parse(start)) / 1e3 : void 0;
+  const base = seconds && seconds > 0 ? windowFromSeconds(seconds) : "monthly";
+  const windows = [];
+  if (used !== void 0) addWin(windows, { window: base, label: `Credits (${windowLabel(base).toLowerCase()})`, percent: used, resets: end });
+  const unified = config.isUnifiedBillingUser === true || config.is_unified_billing_user === true;
+  const products = Array.isArray(config.productUsage ?? config.product_usage) ? config.productUsage ?? config.product_usage : [];
+  const rows = [];
+  for (const raw of products) {
+    const p = asRecord(raw);
+    const pct2 = percent(p?.usagePercent ?? p?.usage_percent ?? p?.creditUsagePercent ?? p?.credit_usage_percent);
+    const name = asString(p?.product ?? p?.name ?? p?.label);
+    if (pct2 !== void 0 && name) rows.push({ name, pct: pct2 });
+  }
+  const slices = unified && (used === void 0 || Math.abs(rows.reduce((s, r) => s + r.pct, 0) - used) <= 1);
+  if (!slices) for (const r of rows) addWin(windows, { window: `${base}:${slug(r.name) || "product"}`, label: titleCase(r.name.replace(/([a-z])([A-Z])/g, "$1 $2")), percent: r.pct, resets: end });
+  if (windows.length === 0 && unified && start && end) addWin(windows, { window: base, label: "Credits", percent: 0, resets: end });
+  const tier = asString(config.subscriptionTier ?? config.subscription_tier ?? config.subscription_tier_display ?? src.subscription_tier_display);
+  return { windows, plan: tier ? titleCase(tier) : void 0 };
+}
+var readGrok = async (deps) => {
+  const out = emptyOutput();
+  const raw = deps.readFile(joinPath(deps.home, ".grok", "auth.json"));
+  if (raw === null) return out;
+  const entries = extractGrokAuth(parseJson(raw));
+  if (entries.length === 0) return out;
+  const entry = entries[0];
+  const exp = entry.expiresAt ? Date.parse(String(entry.expiresAt)) : NaN;
+  if (Number.isFinite(exp) && exp <= deps.now()) {
+    out.issues.push(issue("grok", "default", "expired", issueMessage("expired")));
+    return out;
+  }
+  const headers = { Authorization: `Bearer ${entry.token}`, Accept: "application/json", "x-xai-token-auth": "xai-grok-cli" };
+  try {
+    const parsed = parseGrokBilling(await requestJson(deps, BILLING_URL, { headers }));
+    try {
+      const tier = asRecord(await requestJson(deps, SETTINGS_URL, { headers }));
+      const t = asString(tier?.subscription_tier_display ?? tier?.subscriptionTier);
+      if (t) parsed.plan = titleCase(t);
+    } catch {
+    }
+    if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+    out.readings.push(...toReadings("grok", "default", parsed, "local_login"));
+  } catch (e) {
+    out.issues.push(failure("grok", "default", e));
+  }
+  return out;
+};
+
+// ../usage/src/readers/common.ts
+function keyReader(opts) {
+  return async (deps) => {
+    const out = emptyOutput();
+    const login = opts.find(deps);
+    if (!login) return out;
+    try {
+      const parsed = await opts.fetchParsed(deps, login.key);
+      if (parsed.windows.length === 0) throw new ReaderError("bad_response", issueMessage("bad_response"));
+      out.readings.push(...toReadings(opts.provider, "default", parsed, login.source));
+    } catch (e) {
+      out.issues.push(failure(opts.provider, "default", e));
+    }
+    return out;
+  };
+}
+function envKey(deps, names) {
+  for (const n of names) {
+    const v = asString(deps.env[n])?.trim().replace(/^['"]|['"]$/g, "");
+    if (v) return { key: v, source: "env_key" };
+  }
+  return null;
+}
+function bearer(key) {
+  return { Authorization: `Bearer ${key}`, Accept: "application/json" };
+}
+
+// ../usage/src/readers/kimi.ts
+var HOSTS = ["https://api.kimi.com/coding/v1/usages", "https://api.kimi.ai/coding/v1/usages"];
+var UNIT_SECONDS = { SECOND: 1, MINUTE: 60, HOUR: 3600, DAY: 86400, WEEK: 604800 };
+function percentOf(src) {
+  const s = asRecord(src);
+  const limit = asNumber(s?.limit);
+  if (!s || !limit || limit <= 0) return void 0;
+  const remaining = asNumber(s.remaining);
+  const used = asNumber(s.used) ?? (remaining === void 0 ? void 0 : Math.max(0, limit - remaining));
+  if (used === void 0) return void 0;
+  return { percent: used / limit * 100, resets: pick(s, "reset_at", "resetAt", "reset_time", "resetTime") };
+}
+function parseKimiCodeUsage(json) {
+  const src = asRecord(json);
+  const windows = [];
+  const limits = Array.isArray(src?.limits) ? src.limits : [];
+  limits.forEach((raw, i) => {
+    const item = asRecord(raw);
+    if (!item) return;
+    const span = asRecord(item.window) ?? {};
+    const unit = String(span.timeUnit ?? span.time_unit ?? "").toUpperCase();
+    const per = Object.entries(UNIT_SECONDS).find(([n]) => unit.includes(n))?.[1];
+    const duration = asNumber(span.duration);
+    const base = per && duration ? windowFromSeconds(duration * per) : `limit${i}`;
+    const p = percentOf(item.detail ?? item);
+    if (p) addWin(windows, { window: base, label: per ? windowLabel(base) : "Limit", percent: p.percent, resets: p.resets });
+  });
+  const weekly = percentOf(src?.usage);
+  if (weekly) addWin(windows, { window: "weekly", label: "Weekly", percent: weekly.percent, resets: weekly.resets });
+  return { windows, plan: windows.length ? "Kimi Code" : void 0 };
+}
+var readKimi = keyReader({
+  provider: "kimi",
+  find: (deps) => envKey(deps, ["KIMI_API_KEY", "KIMI_CODE_API_KEY"]),
+  fetchParsed: (deps, key) => firstOk(HOSTS, async (url) => parseKimiCodeUsage(await requestJson(deps, url, { headers: bearer(key) })))
+});
+
+// ../usage/src/readers/minimax.ts
+var GLOBAL = ["https://www.minimax.io/v1/token_plan/remains", "https://api.minimax.io/v1/token_plan/remains"];
+var CN = ["https://api.minimaxi.com/v1/token_plan/remains", "https://www.minimaxi.com/v1/token_plan/remains"];
+function counts(total, count, remainingPercent) {
+  const limit = asNumber(total);
+  const raw = asNumber(count);
+  if (limit && limit > 0 && raw !== void 0) return (limit - raw) / limit * 100;
+  const pct2 = asNumber(remainingPercent);
+  return pct2 === void 0 ? void 0 : 100 - Math.min(100, Math.max(0, pct2));
+}
+function parseMiniMax(json) {
+  const src = asRecord(json) ?? {};
+  const rows = (Array.isArray(src.model_remains) ? src.model_remains : Array.isArray(src.modelRemains) ? src.modelRemains : []).map(asRecord).filter((r) => r !== void 0);
+  const name = (r) => String(r.model_name ?? r.modelName ?? "");
+  const text = rows.filter((r) => /general|chat|text|minimax-m/i.test(name(r)));
+  const pool = text.length ? text : rows.filter((r) => !/video|image|speech|tts|music/i.test(name(r)));
+  const row = (pool.length ? pool : rows)[0];
+  const windows = [];
+  if (row) {
+    const session = counts(pick(row, "current_interval_total_count", "currentIntervalTotalCount"), pick(row, "current_interval_usage_count", "currentIntervalUsageCount"), pick(row, "current_interval_remaining_percent", "currentIntervalRemainingPercent"));
+    if (session !== void 0) addWin(windows, { window: "5h", label: "5 hours", percent: session, resets: pick(row, "end_time", "endTime") });
+    if (row.current_weekly_status !== 3 && row.currentWeeklyStatus !== 3) {
+      const week = counts(pick(row, "current_weekly_total_count", "currentWeeklyTotalCount"), pick(row, "current_weekly_usage_count", "currentWeeklyUsageCount"), pick(row, "current_weekly_remaining_percent", "currentWeeklyRemainingPercent"));
+      if (week !== void 0) addWin(windows, { window: "weekly", label: "Weekly", percent: week, resets: pick(row, "weekly_end_time", "weeklyEndTime") });
+    }
+  }
+  const plan = asString(pick(src, "current_subscribe_title", "current_plan_title", "plan_name", "combo_title", "plan"));
+  return { windows, plan };
+}
+var readMiniMax = keyReader({
+  provider: "minimax",
+  find: (deps) => envKey(deps, ["MINIMAX_API_KEY"]),
+  fetchParsed: (deps, key) => {
+    const hosts = deps.env.MINIMAX_REGION?.toLowerCase() === "cn" ? CN : GLOBAL;
+    return firstOk(hosts, async (url) => {
+      const json = await requestJson(deps, url, { headers: bearer(key) });
+      const base = asRecord(asRecord(json)?.base_resp);
+      if (base && asNumber(base.status_code) !== void 0 && asNumber(base.status_code) !== 0) throw new ReaderError("rejected", issueMessage("rejected"));
+      return parseMiniMax(json);
+    });
+  }
+});
+
+// ../usage/src/readers/opencode.ts
+var URL_2 = "https://opencode.ai/zen/go/v1/usage";
+function parseOpenCodeGoUsage(json) {
+  const usage = asRecord(asRecord(json)?.usage) ?? {};
+  const windows = [];
+  for (const [key, window, label] of [["rolling", "5h", "5 hours"], ["weekly", "weekly", "Weekly"], ["monthly", "monthly", "Monthly"]]) {
+    const row = asRecord(usage[key]);
+    if (row) addWin(windows, { window, label, percent: pick(row, "percent", "usedPercent", "used_percent"), resets: pick(row, "resetsAt", "resets_at") });
+  }
+  return { windows, plan: windows.length ? "Go" : void 0 };
+}
+var readOpenCode = keyReader({
+  provider: "opencode",
+  find: (deps) => {
+    const fromEnv = envKey(deps, ["OPENCODE_API_KEY"]);
+    if (fromEnv) return fromEnv;
+    const data = asRecord(parseJson(deps.readFile(joinPath(deps.env.XDG_DATA_HOME ?? joinPath(deps.home, ".local", "share"), "opencode", "auth.json"))));
+    for (const name of ["opencode-go", "opencode"]) {
+      const entry = asRecord(data?.[name]);
+      const key = asString(entry?.key);
+      if (entry && (!entry.type || entry.type === "api") && key) return { key: key.trim(), source: "local_login" };
+    }
+    return null;
+  },
+  fetchParsed: async (deps, key) => parseOpenCodeGoUsage(await requestJson(deps, URL_2, { headers: bearer(key) }))
+});
+
+// ../usage/src/readers/openrouter.ts
+var URL_3 = "https://openrouter.ai/api/v1/key";
+var INTERVALS = { daily: ["daily", "Daily"], weekly: ["weekly", "Weekly"], monthly: ["monthly", "Monthly"] };
+function nextUtcMidnight(now) {
+  const d = new Date(now);
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + 1)).toISOString();
+}
+function parseOpenRouterKey(json, now) {
+  const data = asRecord(asRecord(json)?.data) ?? {};
+  const windows = [];
+  const budget = asRecord(data.effective_budget);
+  const budgetLimit = asNumber(budget?.limit_usd);
+  const keyLimit = asNumber(data.limit);
+  if (budget && budgetLimit && budgetLimit > 0) {
+    const used = asNumber(budget.spend_usd) ?? Math.max(0, budgetLimit - (asNumber(budget.remaining_usd) ?? budgetLimit));
+    const [window, label] = INTERVALS[String(budget.reset_interval ?? "").toLowerCase()] ?? ["total", "Key limit"];
+    addWin(windows, { window, label, percent: used / budgetLimit * 100, resets: budget.resets_at });
+  } else if (keyLimit && keyLimit > 0) {
+    const remaining = asNumber(data.limit_remaining);
+    const used = remaining === void 0 ? asNumber(data.usage) ?? 0 : Math.max(0, keyLimit - remaining);
+    const [window, label] = INTERVALS[String(data.limit_reset ?? "").toLowerCase()] ?? ["total", "Key limit"];
+    addWin(windows, { window, label, percent: used / keyLimit * 100 });
+  }
+  const free = asRecord(data.free_model_daily_requests);
+  const freeLimit = asNumber(free?.limit);
+  if (free && data.is_free_tier === true && freeLimit && freeLimit > 0) {
+    const used = asNumber(free.used) ?? Math.max(0, freeLimit - (asNumber(free.remaining) ?? freeLimit));
+    addWin(windows, { window: "daily:free", label: "Free requests today", percent: used / freeLimit * 100, resets: nextUtcMidnight(now) });
+  }
+  return { windows, plan: data.is_free_tier === true ? "Free" : "API key" };
+}
+var readOpenRouter = keyReader({
+  provider: "openrouter",
+  find: (deps) => envKey(deps, ["OPENROUTER_API_KEY"]),
+  fetchParsed: async (deps, key) => parseOpenRouterKey(await requestJson(deps, URL_3, { headers: bearer(key) }), deps.now())
+});
+
+// ../usage/src/readers/zai.ts
+var HOSTS2 = ["https://api.z.ai/api/monitor/usage/quota/limit", "https://open.bigmodel.cn/api/monitor/usage/quota/limit"];
+var UNIT_SECONDS2 = { 1: 86400, 3: 3600, 5: 60, 6: 604800 };
+function parseZaiQuota(json) {
+  const data = asRecord(asRecord(json)?.data) ?? {};
+  const windows = [];
+  const limits = Array.isArray(data.limits) ? data.limits : [];
+  limits.forEach((raw) => {
+    const item = asRecord(raw);
+    if (!item) return;
+    const type = String(item.type ?? "").toUpperCase();
+    const resets = pick(item, "nextResetTime", "next_reset_time");
+    if (type === "TOKENS_LIMIT") {
+      const seconds = (UNIT_SECONDS2[asNumber(item.unit) ?? 0] ?? 0) * (asNumber(item.number) ?? 0);
+      const base = seconds ? windowFromSeconds(seconds) : "prompts";
+      addWin(windows, { window: base, label: seconds ? windowLabel(base) : "Prompts", percent: item.percentage, resets });
+    } else if (type === "TIME_LIMIT") {
+      const total = asNumber(item.usage);
+      const current = asNumber(pick(item, "currentValue", "current_value"));
+      const remaining = asNumber(item.remaining);
+      const used = current ?? (total !== void 0 && remaining !== void 0 ? Math.max(0, total - remaining) : void 0);
+      const percent2 = total && total > 0 && used !== void 0 ? used / total * 100 : item.percentage;
+      addWin(windows, { window: "monthly:mcp", label: "MCP calls", percent: percent2, resets });
+    }
+  });
+  const level = asString(pick(data, "planName", "plan_name", "packageName", "level", "plan", "plan_type"));
+  return { windows, plan: level ? `GLM ${titleCase(level.replace(/^glm[\s_-]*/i, ""))}` : windows.length ? "GLM Coding Plan" : void 0 };
+}
+var readZai = keyReader({
+  provider: "zai",
+  find: (deps) => envKey(deps, ["ZAI_API_KEY", "Z_AI_API_KEY", "ZHIPUAI_API_KEY"]),
+  fetchParsed: (deps, key) => firstOk(HOSTS2, async (url) => {
+    const json = asRecord(await requestJson(deps, url, { headers: { Authorization: key, Accept: "application/json" } }));
+    const code = asNumber(json?.code);
+    if (json?.success === false || code !== void 0 && code !== 200) {
+      const bad = code === 401 || code === 403 || code === 1e3 || code === 1001 ? "rejected" : "bad_response";
+      throw new ReaderError(bad, issueMessage(bad));
+    }
+    return parseZaiQuota(json);
+  })
+});
+
+// ../usage/src/collect.ts
+var READERS = {
+  claude: readClaude,
+  codex: readCodex,
+  cursor: readCursor,
+  gemini: readGemini,
+  grok: readGrok,
+  copilot: readCopilot,
+  minimax: readMiniMax,
+  opencode: readOpenCode,
+  openrouter: readOpenRouter,
+  kimi: readKimi,
+  zai: readZai
+};
+async function collectUsage(deps, only) {
+  const entries = Object.entries(READERS).filter(([p]) => !only || only.includes(p));
+  const results = await Promise.all(
+    entries.map(async ([provider, reader]) => {
+      try {
+        return await reader(deps);
+      } catch {
+        const issue2 = { provider, account_label: "default", code: "bad_response", message: "The reader failed unexpectedly." };
+        return { readings: [], issues: [issue2] };
+      }
+    })
+  );
+  const readings = [];
+  const issues = [];
+  for (const r of results) {
+    for (const reading of r.readings) {
+      const ok = usageReadingSchema.safeParse(reading);
+      if (ok.success) readings.push(ok.data);
+    }
+    issues.push(...r.issues);
+  }
+  return { readings, issues };
+}
+async function buildUsagePush(deps, statsDeps) {
+  const [{ readings, issues }, stats] = await Promise.all([collectUsage(deps), statsDeps ? collectMachineStats(statsDeps) : Promise.resolve(void 0)]);
+  const push = { collected_at: new Date(deps.now()).toISOString(), readings, ...issues.length ? { issues } : {} };
+  if (stats) push.stats = stats;
+  return push;
+}
+
+// ../usage/src/node.ts
+import { execFileSync } from "child_process";
+import { readFileSync, readdirSync } from "fs";
+import * as os2 from "os";
+var TIMEOUT_MS = 2e4;
+function exec(cmd, args) {
+  try {
+    return execFileSync(cmd, [...args], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"], maxBuffer: 4 * 1024 * 1024 });
+  } catch {
+    return null;
+  }
+}
+function readFile(path2) {
+  try {
+    return readFileSync(path2, "utf8");
+  } catch {
+    return null;
+  }
+}
+function nodeDeps() {
+  return {
+    async fetch(url, init = {}) {
+      const res = await fetch(url, { method: init.method ?? "GET", headers: init.headers, body: init.body, redirect: "manual", signal: AbortSignal.timeout(TIMEOUT_MS) });
+      return { status: res.status, text: () => res.text(), headers: Object.fromEntries([...res.headers].map(([k, v]) => [k.toLowerCase(), v])) };
+    },
+    readFile,
+    readDir(path2) {
+      try {
+        return readdirSync(path2);
+      } catch {
+        return [];
+      }
+    },
+    env: process.env,
+    home: os2.homedir(),
+    platform: process.platform,
+    now: () => Date.now(),
+    exec
+  };
+}
+function nodeStatsDeps() {
+  return {
+    platform: process.platform,
+    totalmem: () => os2.totalmem(),
+    freemem: () => os2.freemem(),
+    cpuTimes() {
+      let idle = 0;
+      let total = 0;
+      for (const c of os2.cpus()) {
+        idle += c.times.idle;
+        total += c.times.user + c.times.nice + c.times.sys + c.times.idle + c.times.irq;
+      }
+      return { idle, total };
+    },
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    readFile,
+    exec
+  };
+}
+
+// src/service/usage-push.ts
+async function claudeSessionTokens(scan, readEnv) {
+  const out = /* @__PURE__ */ new Set();
+  for (const p of scan.procs) {
+    if (p.tool !== "claude") continue;
+    const t = await readEnv(p.pid, "CLAUDE_CODE_OAUTH_TOKEN");
+    if (t && /^[\w.~+/=-]{20,400}$/.test(t)) out.add(t);
+  }
+  return [...out];
+}
+async function collectUsagePush(ctx) {
+  const platform = ctx.platform ?? process.platform;
+  const run = ctx.run ?? runCmd;
+  let tokens = [];
+  try {
+    const readEnv = makeEnvReader(platform, run);
+    tokens = await claudeSessionTokens(await scanProcesses({ platform, run, env: ctx.env, readEnv }), readEnv);
+  } catch {
+  }
+  return buildUsagePush({ ...nodeDeps(), claudeTokens: tokens }, nodeStatsDeps());
+}
+
+// src/service/run.ts
+var FLUSH_EVERY_MS = 2e3;
+var FLUSH_BUDGET_MS = 5e3;
+var DISCOVERY_EVERY_MS = 6e4;
+var BEAT_EVERY_MS = 1e4;
+var USAGE_EVERY_MS = 5 * 6e4;
+var USAGE_FIRST_MS = 1e4;
+var BACKOFF_MAX_MS = 3e5;
+var LOG_MAX_BYTES = 1024 * 1024;
+var newSched = (now) => ({ heartbeat: now, flush: now, discovery: now + 5e3, usage: now + USAGE_FIRST_MS, beat: 0, failures: 0, quietUntil: 0, interval: MACHINE_HEARTBEAT_SECONDS * 1e3, logged: "", started: now, stop: false });
+function backoffMs(failures, random) {
+  const base = Math.min(BACKOFF_MAX_MS, MACHINE_HEARTBEAT_SECONDS * 1e3 * 2 ** Math.max(0, failures - 1));
+  return Math.max(MACHINE_MIN_INTERVAL_SECONDS * 1e3, Math.round(base * (0.8 + 0.4 * random())));
+}
+function log(st, now, state) {
+  if (st.logged === state) return;
+  st.logged = state;
+  try {
+    fs2.mkdirSync(configDir(), { recursive: true, mode: 448 });
+    const f = serviceLogFile();
+    let size = 0;
+    try {
+      size = fs2.statSync(f).size;
+    } catch {
+    }
+    if (size > LOG_MAX_BYTES) fs2.writeFileSync(f, "", { mode: 384 });
+    fs2.appendFileSync(f, `${new Date(now).toISOString()} ${state}
+`, { mode: 384 });
+  } catch {
+  }
+}
+async function call(deps, m, path2, body) {
+  try {
+    const r = await apiRequest(deps.ctx, m.host, `/api/v1/machine${path2}`, { method: "POST", token: m.token, body, timeoutMs: 1e4 });
+    if (r.status >= 200 && r.status < 300) return { outcome: "ok", json: r.json };
+    if (r.status === 401) return { outcome: "revoked" };
+    if (r.status === 429 || r.status >= 500) return { outcome: "retry" };
+    return { outcome: "drop" };
+  } catch {
+    return { outcome: "retry" };
+  }
+}
+function fail(st, deps, now, what) {
+  st.failures += 1;
+  st.lastError = what;
+  st.quietUntil = now + backoffMs(st.failures, deps.random ?? Math.random);
+  log(st, now, `error ${what}; retrying in ${Math.round((st.quietUntil - now) / 1e3)}s`);
+}
+function succeed(st, now) {
+  if (st.failures > 0) log(st, now, "online");
+  st.failures = 0;
+  st.quietUntil = 0;
+  st.lastOk = now;
+  st.lastError = void 0;
+}
+function beat(st, now) {
+  st.beat = now;
+  writeServiceState({ pid: process.pid, beat: now, started: st.started, ...st.lastOk ? { last_ok: st.lastOk } : {}, ...st.lastError ? { last_error: st.lastError } : {} });
+}
+async function serviceStep(deps, st) {
+  const now = deps.ctx.now();
+  const m = readMachine();
+  if (!m || m.revoked) {
+    log(st, now, "stopped: not connected");
+    return false;
+  }
+  const revoke = () => {
+    writeMachine({ ...m, revoked: true });
+    log(st, now, "stopped: the server no longer knows this machine (removed?)");
+    return false;
+  };
+  if (now - st.beat >= BEAT_EVERY_MS) {
+    beat(st, now);
+  }
+  if (now < st.quietUntil) return true;
+  if (now >= st.heartbeat) {
+    const stats = await collectStats(deps.collectors);
+    const r = await call(deps, m, "/heartbeat", { os: cliVersionOs(), cli_version: VERSION, ...stats ? { stats } : {} });
+    if (r.outcome === "revoked") return revoke();
+    if (r.outcome === "ok") {
+      const parsed = machineHeartbeatResponseSchema.safeParse(r.json);
+      const secs = parsed.success ? parsed.data.interval : MACHINE_HEARTBEAT_SECONDS;
+      st.interval = Math.max(MACHINE_MIN_INTERVAL_SECONDS, secs) * 1e3;
+      st.heartbeat = now + st.interval;
+      succeed(st, now);
+      if (st.logged === "") log(st, now, "online");
+    } else {
+      fail(st, deps, now, r.outcome === "drop" ? "heartbeat rejected" : "server unreachable");
+      st.heartbeat = st.quietUntil;
+      return true;
+    }
+  }
+  if (now >= st.flush) {
+    st.flush = now + FLUSH_EVERY_MS;
+    const claim = takeSpool(machineSpoolFile());
+    if (claim) {
+      const pending = claim.events;
+      const unsent = [];
+      const deadline = deps.ctx.now() + (deps.flushBudgetMs ?? FLUSH_BUDGET_MS);
+      let down = false;
+      let outOfTime = false;
+      for (let k = 0; k < pending.length; k += HOOK_BATCH_MAX) {
+        const batch = pending.slice(k, k + HOOK_BATCH_MAX);
+        if (down || outOfTime) {
+          unsent.push(...batch);
+          continue;
+        }
+        if (deps.ctx.now() >= deadline) {
+          unsent.push(...batch);
+          outOfTime = true;
+          continue;
+        }
+        const r = await call(deps, m, "/hooks", { events: batch });
+        if (r.outcome === "revoked") {
+          releaseSpool(claim, [...unsent, ...pending.slice(k)], machineSpoolFile());
+          return revoke();
+        }
+        if (r.outcome === "retry") {
+          unsent.push(...batch);
+          down = true;
+        }
+        if (r.outcome === "ok") stashNudges(nudgesOf(r.json), deps.ctx.now());
+        beat(st, deps.ctx.now());
+      }
+      releaseSpool(claim, unsent, machineSpoolFile());
+      if (down) {
+        fail(st, deps, now, "server unreachable");
+        return true;
+      }
+      succeed(st, now);
+    }
+  }
+  if (now >= st.discovery) {
+    st.discovery = now + DISCOVERY_EVERY_MS;
+    let profiles = [];
+    try {
+      profiles = await (deps.profiles ?? (async () => buildProfiles(await scanProcesses({ platform: deps.ctx.platform ?? process.platform, run: deps.ctx.run ?? runCmd, env: deps.ctx.env }), deps.ctx.env, void 0, m.installed.claude_dirs)))();
+    } catch {
+    }
+    const r = await call(deps, m, "/discovery", { profiles });
+    if (r.outcome === "revoked") return revoke();
+    if (r.outcome === "retry") {
+      fail(st, deps, now, "server unreachable");
+      st.discovery = st.quietUntil;
+    } else if (r.outcome === "ok") succeed(st, now);
+  }
+  if (now >= st.usage) {
+    st.usage = now + USAGE_EVERY_MS;
+    let body = null;
+    try {
+      body = await (deps.usage ?? (() => collectUsagePush(deps.ctx)))();
+    } catch {
+    }
+    if (body) {
+      const r = await call(deps, m, "/usage", body);
+      if (r.outcome === "revoked") return revoke();
+      if (r.outcome === "retry") st.usage = now + 6e4;
+      else if (r.outcome === "ok") succeed(st, now);
+    }
+  }
+  return true;
+}
+async function runService(deps) {
+  const st = newSched(deps.ctx.now());
+  const stop = () => {
+    st.stop = true;
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  try {
+    while (!st.stop) {
+      const more = await serviceStep(deps, st);
+      if (!more) return 0;
+      await deps.ctx.sleep(500);
+    }
+    return 0;
+  } finally {
+    process.off("SIGTERM", stop);
+    process.off("SIGINT", stop);
+  }
+}
+export {
+  BACKOFF_MAX_MS,
+  BEAT_EVERY_MS,
+  DISCOVERY_EVERY_MS,
+  FLUSH_BUDGET_MS,
+  FLUSH_EVERY_MS,
+  LOG_MAX_BYTES,
+  USAGE_EVERY_MS,
+  USAGE_FIRST_MS,
+  backoffMs,
+  newSched,
+  runService,
+  serviceStep
+};