owlmem 0.9.0 → 0.9.1

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.1";
 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();
@@ -1392,18 +1392,37 @@ 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];
+    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,
+             ...(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 +1470,28 @@ 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 });
+  }
+  return out;
+}
 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 r = await api("usage", { days: usageReport(state, clients), status: usageStatus(state, clients) });
   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.1",
   "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" },