owlmem 0.9.0 → 0.9.2

package/owlmem.mjs

@@ -41,7 +41,7 @@ import { join, dirname, basename, relative, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
 
-export const VERSION = "0.9.0";
+export const VERSION = "0.9.2";
 const BASE = (process.env.OWLMEM_URL || "https://owlmem.com").replace(/\/$/, "");
 const DIR = process.env.OWLMEM_HOME || join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "owlmem");
 const enc = new TextEncoder(), dec = new TextDecoder();
@@ -1237,6 +1237,7 @@ export async function wakeLoop(o) {
       await sleep(backoff); continue;
     }
     backoff = 0;
+    if (Array.isArray(r.data.agents)) cfg.live = r.data.agents;       // which AIs the owner lets us read Claude quota for (read_quota)
     for (const t of r.data.tasks || []) {
       const plan = isReply(t) ? { kind: "scratch" } : o.plan ? o.plan(t) : planWorkdir(t);      // a reply is read in an empty folder
       log((isReply(t) ? "Reply #" + t.id + " (task #" + t.task_id + ")" : jobLabel(t)) + " for " + t.agent + ": starting " + t.client + (plan.dir ? " in " + plan.dir : "") + ".");
@@ -1392,18 +1393,39 @@ const usageAdd = (days, d, u) => { const x = days[d] || (days[d] = { input: 0, o
 // One line of a transcript → [day, usage] or null. f keeps what a file needs between lines (Claude: message ids seen; Codex: last total).
 export function usageLine(client, line, f) {
   if (client === "claude-code") {
-    if (!line.includes('"usage"')) return null;
+    const err = line.includes('"isApiErrorMessage":true');
+    if (!err && !line.includes('"usage"')) return null;
     let j; try { j = JSON.parse(line); } catch { return null; }
-    const m = j?.message, u = m?.usage, d = usageDay(j?.timestamp);
+    const m = j?.message, u = m?.usage, d = usageDay(j?.timestamp), at = Math.floor(Date.parse(j?.timestamp) / 1000) || 0;
+    if (err) {                              // the app's own error message in the transcript: out of quota, or signed out
+      const text = (Array.isArray(m?.content) ? m.content : []).map((b) => b?.text || "").join(" ");
+      const kind = j.error === "rate_limit" || /usage limit|hit your limit|limit reached|rate.?limit/i.test(text) ? "limit" : j.error === "authentication_failed" || /authenticat|log ?in|oauth/i.test(text) ? "auth" : null;
+      if (kind && at >= (f.st?.block_at || 0)) { const r = /\|(\d{10})\b/.exec(text); f.st = { ...f.st, block: kind, block_at: at, resets_at: r ? Number(r[1]) : undefined }; }
+      return null;
+    }
     if (j?.type !== "assistant" || !u || !d) return null;
+    if (at > (f.st?.ok_at || 0)) f.st = { ...f.st, ok_at: at };
     const id = (m.id || "") + ":" + (j.requestId || "");          // Claude Code writes one line per content block, each with the message's usage
     f.ids = f.ids || [];
     if (m.id && f.ids.includes(id)) return null;
     if (m.id) { f.ids.push(id); if (f.ids.length > 200) f.ids.shift(); }
     return [d, { input: u.input_tokens, output: u.output_tokens, cache_read: u.cache_read_input_tokens, cache_write: u.cache_creation_input_tokens }];
   }
-  if (!line.includes('"token_count"')) return null;
+  if (!line.includes('"token_count"') && !line.includes('"error"')) return null;
   let j; try { j = JSON.parse(line); } catch { return null; }
+  const at = Math.floor(Date.parse(j?.timestamp) / 1000) || 0;
+  if (j?.payload?.type === "error") {
+    if (/usage limit|rate.?limit|quota/i.test(String(j.payload.message || "")) && at >= (f.st?.block_at || 0)) f.st = { ...f.st, block: "limit", block_at: at };
+    return null;
+  }
+  const rl = j?.payload?.type === "token_count" ? j.payload.rate_limits : null;
+  if (rl && at >= (f.st?.limit_at || 0)) {   // Codex says how much of its plan's window is used and when it resets
+    const w = [rl.primary, rl.secondary].filter((x) => x && typeof x.used_percent === "number").sort((a, b) => b.used_percent - a.used_percent)[0];
+    const windows = [rl.primary, rl.secondary].filter((x) => x && typeof x.used_percent === "number")
+      .map((x) => ({ minutes: x.window_minutes, used_percent: x.used_percent, resets_at: x.resets_at }));
+    f.st = { ...f.st, limit_at: at, ok_at: at, used_percent: w?.used_percent, resets_at: w?.resets_at, window_minutes: w?.window_minutes, windows,
+             ...(rl.rate_limit_reached_type ? { block: "limit", block_at: at } : {}) };
+  }
   const info = j?.payload?.type === "token_count" ? j.payload.info : null, last = info?.last_token_usage, d = usageDay(j?.timestamp);
   if (!last || !d) return null;
   const total = info.total_token_usage?.total_tokens;
@@ -1451,14 +1473,62 @@ export function usageReport(state, clients, now = Date.now()) {
   }
   return out;
 }
+// The newest quota state per app: what its latest transcript says (Claude Code: an out-of-quota or signed-out error after
+// the last answer; Codex: percent of its plan's window used, when it resets).
+export function usageStatus(state, clients) {
+  const out = {};
+  for (const f of Object.values(state.files || {})) {
+    if (!clients.includes(f.client) || !f.st) continue;
+    const o = out[f.client] || (out[f.client] = {});
+    if ((f.st.ok_at || 0) > (o.ok_at || 0)) o.ok_at = f.st.ok_at;
+    if ((f.st.block_at || 0) > (o.block_at || 0)) Object.assign(o, { block: f.st.block, block_at: f.st.block_at, resets_at: f.st.resets_at ?? o.resets_at });
+    if ((f.st.limit_at || 0) > (o.limit_at || 0)) Object.assign(o, { limit_at: f.st.limit_at, used_percent: f.st.used_percent, window_minutes: f.st.window_minutes, resets_at: f.st.resets_at, windows: f.st.windows });
+  }
+  return out;
+}
+// Claude Code's own quota (0.9.2, only when the AI's owner turned "Read Claude quota" on in the console): ask Anthropic's
+// usage endpoint with the sign-in Claude Code keeps on this computer, the same one its /usage screen uses. The sign-in is
+// only sent to api.anthropic.com and never leaves this computer otherwise; OwlMem gets the percentages and reset times.
+// An expired sign-in isn't refreshed here (Claude Code does that itself): no quota this round.
+export function claudeToken(h = home(), env = process.env, plat = process.platform, now = Date.now()) {
+  let raw = null;
+  try { raw = readFileSync(join(env.CLAUDE_CONFIG_DIR || join(h, ".claude"), ".credentials.json"), "utf8"); } catch {}
+  if (!raw && plat === "darwin") {
+    const r = spawnSync("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", timeout: 10000 });
+    if (r.status === 0) raw = r.stdout;
+  }
+  let o; try { o = JSON.parse(raw || "null")?.claudeAiOauth; } catch { return null; }
+  if (!o?.accessToken || (o.expiresAt && o.expiresAt < now + 60000)) return null;
+  return o.accessToken;
+}
+export function claudeWindows(j) {
+  const sec = (v) => { const t = Date.parse(v); return isNaN(t) ? undefined : Math.floor(t / 1000); };
+  return [["five_hour", 300], ["seven_day", 10080]].filter(([k]) => typeof j?.[k]?.utilization === "number")
+    .map(([k, minutes]) => ({ minutes, used_percent: j[k].utilization, resets_at: sec(j[k].resets_at) }));
+}
+async function claudeQuota(fetchImpl = fetch) {
+  const tok = claudeToken();
+  if (!tok) return null;
+  const r = await fetchImpl("https://api.anthropic.com/api/oauth/usage", { headers: { Authorization: "Bearer " + tok, "anthropic-beta": "oauth-2025-04-20", "User-Agent": "owlmem-cli/" + VERSION },
+                                                                          signal: AbortSignal.timeout(15000) });
+  if (!r.ok) return null;
+  const w = claudeWindows(await r.json());
+  return w.length ? w : null;
+}
 async function usageTick(cfg, api, log, dir = DIR) {
   const file = join(wakeDir(dir), "usage.json");
   let state = {}; try { state = JSON.parse(readFileSync(file, "utf8")); } catch {}
+  if (state.v !== 2) state = { v: 2 };         // 0.9.1 also reads quota state: read every file once more
   const clients = Object.keys(cfg.clients || {}).filter((c) => c in usageRoots());
   if (!clients.length) return;
   scanUsage(state, Object.fromEntries(Object.entries(usageRoots()).filter(([c]) => clients.includes(c))));
   try { writeFileSync(file + ".tmp", JSON.stringify(state)); renameSync(file + ".tmp", file); } catch (e) { log("usage: " + e.message); }
-  const r = await api("usage", { days: usageReport(state, clients) });
+  const status = usageStatus(state, clients);
+  if (clients.includes("claude-code") && (cfg.live || []).some((a) => a.client === "claude-code" && a.read_quota)) {
+    const w = await claudeQuota().catch(() => null);
+    if (w) status["claude-code"] = { ...status["claude-code"], windows: w, limit_at: Math.floor(Date.now() / 1000) };
+  }
+  const r = await api("usage", { days: usageReport(state, clients), status });
   if (r.status !== 200 && r.status !== 404) log("usage: OwlMem answered " + (r.data?.detail || "HTTP " + r.status));
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owlmem",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "OwlMem command line: connect your AI apps to OwlMem in one command (npx -y owlmem install), an end-to-end encrypted vault for your AI agents, and a local MCP server.",
   "type": "module",
   "bin": { "owlmem": "owlmem.mjs" },