owlmem 0.7.9 → 0.9.0

package/owlmem.mjs

@@ -34,14 +34,14 @@
 // device key there, so standing grants don't apply. Viewing, writing, deleting and exporting always need approval.
 
 import { webcrypto as crypto, createHash } from "node:crypto";
-import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, copyFileSync, rmSync, statSync, realpathSync, openSync, closeSync, appendFileSync, renameSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, copyFileSync, rmSync, statSync, realpathSync, openSync, closeSync, appendFileSync, renameSync, readdirSync, readSync } from "node:fs";
 import { gunzipSync } from "node:zlib";
 import { homedir, hostname, userInfo } from "node:os";
 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.7.9";
+export const VERSION = "0.9.0";
 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();
@@ -1074,10 +1074,13 @@ export function prepareWorkdir(task, plan, dir = DIR, git = gitRun) {
   return { cwd: rel ? join(wt, rel) : wt, worktree: wt, branch, repo: plan.top };
 }
 
-// A job from OwlMem is a task given to this AI (type "task"), or the result of a task this AI gave someone else (type "reply":
-// the automatic note sent when that task was done or declined). Older OwlMem servers send no type: a task.
+// A job from OwlMem is a task given to this AI (type "task"), the result of a task this AI gave someone else (type "reply":
+// the automatic note sent when that task was done or declined), or a note a person sent this AI (type "note", 0.8.0).
+// Older OwlMem servers send no type: a task.
 const isReply = (t) => t?.type === "reply";
-const jobName = (t) => (isReply(t) ? "reply-" : "task-") + t.id;
+const isNote = (t) => t?.type === "note";
+const jobLabel = (t) => (isReply(t) ? "Reply #" : isNote(t) ? "Note #" : "Task #") + t.id;
+const jobName = (t) => (isReply(t) ? "reply-" : isNote(t) ? "note-" : "task-") + t.id;
 const shortName = (who) => { who = String(who || ""); return who.startsWith("user:") ? who.slice(5) : who.includes("/") ? who.split("/").slice(1).join("/") : who; };
 
 // Woken for a reply: read it (kb_inbox marks it read; that's how OwlMem knows it was handled), act on it only if needed.
@@ -1099,8 +1102,44 @@ Never put passwords, tokens, keys or other secrets in any message. You have ${mi
 `;
 }
 
+// Woken for a note a person sent this AI: a person writing to an AI usually wants something done, whichever kind they picked.
+// Read it (kb_inbox marks it read; that's how OwlMem knows it was handled), do it if it asks for something, and tell them the result.
+export function notePrompt(n, place, o = {}) {
+  const who = shortName(n.from), mins = o.timeout_min || WAKE_DEFAULTS.timeout_min;
+  const where = place.worktree
+    ? (n.zh ? `在 ${place.cwd} 里做（${place.repo} 的独立 git 工作树，分支 ${place.branch}；只在这个分支提交，不合并、不推送别的分支，结果里写上分支名）。`
+      : `Work in ${place.cwd}. It is a separate git worktree of ${place.repo} on the branch ${place.branch}. Commit on this branch only, don't merge or push other branches, and put the branch name in your result.`)
+    : place.scratch ? (n.zh ? `留言没指定目录：你在一个空文件夹（${place.cwd}）里。` : `The note names no project directory: you are in an empty folder (${place.cwd}).`)
+    : (n.zh ? `在 ${place.cwd} 里做。` : `Work in ${place.cwd}.`);
+  if (n.zh) return `奥麦自动唤醒在 ${o.machine || "这台电脑"} 上启动了你（${n.agent}），因为 ${who}（人）给你发了一条留言。没有人在看这个会话，也没人能回答问题。
+
+留言 #${n.id}：${n.title}
+
+${n.body || "（没有正文）"}
+
+先用 kb_inbox 看这条留言（会标成已读）。${where}
+- 它要你做事：不需要人参与的就直接做完，然后用 kb_send 发给 ${n.from}（kind=note）报结果，标题一句话说结果。
+- 做不了（要人输验证码、被安全检查拦下、要动有风险的线上服务）：不要硬做，用 kb_send 告诉 ${n.from} 卡在哪、需要他做什么。
+- 只是告诉你一件事、不用做什么：看完就结束，不要发消息。
+不要把密码、令牌、密钥写进任何消息。你有 ${mins} 分钟。
+`;
+  return `OwlMem auto-wake started you (${n.agent}) on ${o.machine || "this computer"} because ${who}, a person, sent you a note. Nobody is watching this session and nobody can answer questions.
+
+Note #${n.id}: ${n.title}
+
+${n.body || "(no details)"}
+
+First read it with kb_inbox (that marks it read). ${where}
+- If it asks you to do something you can do without a person, do it, then tell ${n.from} the result with kb_send (kind=note), with the result in one line as the title.
+- If you can't (it needs a code typed in, a safety check stops you, or it means a risky change to a live service), don't force it: tell ${n.from} with kb_send what is blocking and what they need to do.
+- If it only tells you something, end here and don't send any message.
+Never put passwords, tokens, keys or other secrets in any message. You have ${mins} minutes.
+`;
+}
+
 export function wakePrompt(task, place, o = {}) {
   if (isReply(task)) return replyPrompt(task, o);
+  if (isNote(task)) return notePrompt(task, place, o);
   const id = task.id, mins = o.timeout_min || WAKE_DEFAULTS.timeout_min;
   const where = place.worktree
     ? `Work in ${place.cwd}. It is a separate git worktree of ${place.repo} on the branch ${place.branch}, made for this task so it doesn't collide with other work. Commit your changes on this branch only. Don't merge, rebase or push other branches, and don't touch ${place.repo} itself. Put the branch name in your result so a person can review and merge it.`
@@ -1142,7 +1181,7 @@ export async function runTask(task, cfg, o = {}) {
       let ch, timedOut = false, killer = null;
       try {
         ch = spawn(argv[0], argv.slice(1), { cwd: place.cwd, stdio: ["pipe", fd, fd], detached: !win, shell: win, windowsHide: true,
-          env: { ...process.env, OWLMEM_NO_BROWSER: "1", [isReply(task) ? "OWLMEM_WAKE_REPLY" : "OWLMEM_WAKE_TASK"]: String(task.id) } });
+          env: { ...process.env, OWLMEM_NO_BROWSER: "1", [isReply(task) ? "OWLMEM_WAKE_REPLY" : isNote(task) ? "OWLMEM_WAKE_NOTE" : "OWLMEM_WAKE_TASK"]: String(task.id) } });
       } catch (e) { res({ outcome: "error", detail: "couldn't start " + argv[0] + ": " + e.message }); return; }
       const kill = (sig) => { try { if (win) spawnSync("taskkill", ["/T", "/F", "/PID", String(ch.pid)]); else process.kill(-ch.pid, sig); } catch { try { ch.kill(sig); } catch {} } };
       const timer = setTimeout(() => { timedOut = true; kill("SIGTERM"); killer = setTimeout(() => kill("SIGKILL"), 10000); }, ms);
@@ -1200,7 +1239,7 @@ export async function wakeLoop(o) {
     backoff = 0;
     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 + ")" : "Task #" + t.id) + " for " + t.agent + ": starting " + t.client + (plan.dir ? " in " + plan.dir : "") + ".");
+      log((isReply(t) ? "Reply #" + t.id + " (task #" + t.task_id + ")" : jobLabel(t)) + " for " + t.agent + ": starting " + t.client + (plan.dir ? " in " + plan.dir : "") + ".");
       sched.add({ id: t.id, agent: t.agent, lock: plan.lock || null, task: t, plan });
     }
     // OwlMem says a newer version is out: update only while nothing runs or waits (no task is cut off), then restart
@@ -1216,12 +1255,13 @@ export async function wakeLoop(o) {
 // The program runs its own copy (wake/owlmem.mjs). When OwlMem's poll answer names a newer version (latest), and nothing is
 // running: download that version's package from the npm registry, check it against the registry's sha512, take owlmem.mjs
 // out of it, check that it runs and says it is that version, then swap it in (rename in the same folder, so it's all or
-// nothing) and restart. If anything fails the old copy keeps running, and that version isn't tried again for 24 hours.
+// nothing) and restart. If anything fails the old copy keeps running, and that version isn't tried again for 24 hours;
+// except a 404 for the version: npm takes a few minutes to serve a new one everywhere, so that's tried again in 10 minutes.
 // Restart: on Linux and macOS the program exits with WAKE_RESTART_CODE; the systemd unit (Restart=on-failure) and the
 // LaunchAgent (KeepAlive unless the exit was successful) start it again 30 s later. On Windows nothing watches it, so it
 // starts the new copy itself (detached, like the logon launcher) and then exits.
 export const WAKE_RESTART_CODE = 75;
-const UPDATE_RETRY = 24 * 3600 * 1000;
+const UPDATE_RETRY = 24 * 3600 * 1000, UPDATE_NOT_YET = 10 * 60 * 1000;
 const REGISTRY = () => String(process.env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
 export function newer(a, b) {
   const p = (v) => (/^\d+\.\d+\.\d+$/.test(String(v || "")) ? String(v).split(".").map(Number) : null);
@@ -1243,16 +1283,22 @@ export function tarFile(tgz, want = "package/owlmem.mjs") {
   }
   return null;
 }
-// → "restart" (new copy in place) | "skip" (tried that version less than 24 h ago) | "failed" (old copy stays)
+// → "restart" (new copy in place) | "skip" (tried that version less than 24 h ago, or 10 min for a 404) | "failed" (old copy stays)
 export async function wakeUpdate(latest, o = {}) {
   const dir = o.dir || DIR, log = o.log || (() => {}), now = o.now || Date.now, get = o.fetch || fetch;
   const wd = wakeDir(dir), state = join(wd, "update.json"), target = join(wd, "owlmem.mjs"), tmpFile = join(wd, "owlmem.update.mjs");
   let st = {}; try { st = JSON.parse(readFileSync(state, "utf8")); } catch {}
-  if (st.version === latest && now() - (st.at || 0) < UPDATE_RETRY) return "skip";
-  try { mkdirSync(wd, { recursive: true }); writeFileSync(state, JSON.stringify({ version: latest, at: now() }) + "\n"); } catch {}
+  if (st.version === latest && now() - (st.at || 0) < (st.wait || UPDATE_RETRY)) return "skip";
+  const mark = (wait) => { try { mkdirSync(wd, { recursive: true }); writeFileSync(state, JSON.stringify({ version: latest, at: now(), ...(wait ? { wait } : {}) }) + "\n"); } catch {} };
+  mark();
   log("Updating auto-wake from " + VERSION + " to " + latest + ".");
   try {
     const meta = await get(REGISTRY() + "/owlmem/" + encodeURIComponent(latest), { signal: AbortSignal.timeout(60000) });
+    if (meta.status === 404) {
+      mark(UPDATE_NOT_YET);
+      log(latest + " isn't on npm yet; trying again in 10 minutes.");
+      return "failed";
+    }
     if (!meta.ok) throw new Error("registry answered HTTP " + meta.status);
     const dist = (await meta.json())?.dist || {};
     const m = /^sha512-(.+)$/.exec(String(dist.integrity || ""));
@@ -1322,13 +1368,107 @@ export function wakeTools(cfg, home_ = home(), env = process.env) {
   return changed;
 }
 
+// ── token usage (0.9.0) ──
+// An AI can't see how many tokens it used, but its app records them on this computer. Auto-wake adds them up per app and
+// UTC day and tells OwlMem every USAGE_EVERY, so every agent in the space can see who is busy (kb_team). Read: Claude Code's
+// transcripts (~/.claude/projects/**/*.jsonl, message.usage, each message once) and Codex's sessions (~/.codex/sessions/**/
+// *.jsonl, token_count events). Only the numbers leave the computer — no text, no paths. Files are read from where the last
+// scan stopped (usage.json in the wake folder), so a scan only reads what's new.
+export const USAGE_EVERY = 10 * 60 * 1000, USAGE_DAYS = 8, USAGE_KEEP = 35;
+const usageDay = (ts) => { const d = new Date(ts); return isNaN(d) ? null : d.toISOString().slice(0, 10); };
+export function usageRoots(h = home(), env = process.env) {
+  return { "claude-code": join(env.CLAUDE_CONFIG_DIR || join(h, ".claude"), "projects"), codex: join(env.CODEX_HOME || join(h, ".codex"), "sessions") };
+}
+function jsonlFiles(dir, since, out = []) {
+  let ents = []; try { ents = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of ents) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) jsonlFiles(p, since, out);
+    else if (e.name.endsWith(".jsonl")) { try { const st = statSync(p); if (st.mtimeMs >= since) out.push([p, st.size]); } catch {} }
+  }
+  return out;
+}
+const usageAdd = (days, d, u) => { const x = days[d] || (days[d] = { input: 0, output: 0, cache_read: 0, cache_write: 0 }); for (const k in x) x[k] += Math.max(0, Number(u[k]) || 0); };
+// 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;
+    let j; try { j = JSON.parse(line); } catch { return null; }
+    const m = j?.message, u = m?.usage, d = usageDay(j?.timestamp);
+    if (j?.type !== "assistant" || !u || !d) return null;
+    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;
+  let j; try { j = JSON.parse(line); } catch { return null; }
+  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;
+  if (total != null && total === f.total) return null;           // Codex repeats the event when nothing new was used
+  f.total = total;
+  const cached = Number(last.cached_input_tokens) || 0;
+  return [d, { input: (Number(last.input_tokens) || 0) - cached, output: last.output_tokens, cache_read: cached, cache_write: last.cache_write_input_tokens }];
+}
+export function scanUsage(state, roots = usageRoots(), now = Date.now()) {
+  state.files = state.files || {};
+  const since = now - USAGE_KEEP * 86400000;
+  for (const [client, dir] of Object.entries(roots)) {
+    for (const [p, size] of jsonlFiles(dir, since)) {
+      let f = state.files[p];
+      if (!f || f.client !== client || size < f.off) f = state.files[p] = { client, off: 0, days: {} };
+      if (size === f.off) continue;
+      let fd; try { fd = openSync(p, "r"); } catch { continue; }
+      try {
+        const buf = Buffer.alloc(1 << 20); let rest = "", pos = f.off;
+        for (;;) {
+          const n = readSync(fd, buf, 0, buf.length, pos); if (n <= 0) break;
+          pos += n;
+          const text = rest + buf.toString("utf8", 0, n), cut = text.lastIndexOf("\n");
+          if (cut < 0) { rest = text; continue; }
+          for (const l of text.slice(0, cut).split("\n")) { const r = usageLine(client, l, f); if (r) usageAdd(f.days, r[0], r[1]); }
+          rest = text.slice(cut + 1);
+        }
+        f.off = pos - Buffer.byteLength(rest);           // an unfinished last line is read again next time
+      } finally { closeSync(fd); }
+    }
+  }
+  const lo = usageDay(since);
+  for (const [p, f] of Object.entries(state.files)) {
+    for (const d of Object.keys(f.days)) if (d < lo) delete f.days[d];
+    if (!Object.keys(f.days).length && !existsSync(p)) delete state.files[p];
+  }
+  return state;
+}
+// The last USAGE_DAYS days, per day and app, for the apps auto-wake runs here: {"2026-10-30": {"claude-code": {input, …}}}.
+export function usageReport(state, clients, now = Date.now()) {
+  const lo = usageDay(now - (USAGE_DAYS - 1) * 86400000), out = {};
+  for (const f of Object.values(state.files || {})) {
+    if (!clients.includes(f.client)) continue;
+    for (const [d, u] of Object.entries(f.days)) if (d >= lo) usageAdd(out[d] || (out[d] = {}), f.client, u);
+  }
+  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 {}
+  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) });
+  if (r.status !== 200 && r.status !== 404) log("usage: OwlMem answered " + (r.data?.detail || "HTTP " + r.status));
+}
+
 async function wakeRun() {
   const cfg = loadWake();
   if (!cfg) throw new Fail("Auto-wake isn't set up on this computer. Run: npx -y owlmem wake enable");
   const log = wakeLogger(), api = wakeApi();
   try { if (wakeTools(cfg)) { saveWake(DIR, cfg); log("Unattended runs may now also use: " + WAKE_TOOLS.join(", ") + "."); } } catch (e) { log("tools: " + e.message); }
   const report = async (j, res) => {
-    log((isReply(j.task) ? "Reply #" : "Task #") + j.id + ": " + res.outcome + (res.code != null ? " (exit code " + res.code + ")" : "") + (res.detail ? " — " + res.detail : ""));
+    log(jobLabel(j.task) + ": " + res.outcome + (res.code != null ? " (exit code " + res.code + ")" : "") + (res.detail ? " — " + res.detail : ""));
     for (let i = 0; i < 5; i++) {
       const r = await api("report", { id: j.id, outcome: res.outcome, code: res.code ?? null, detail: res.detail || "" });
       if (r.status === 200 || r.status === 404 || r.status === 401) return;
@@ -1337,6 +1477,8 @@ async function wakeRun() {
   };
   const sched = new Scheduler({ max: cfg.max_parallel || WAKE_DEFAULTS.max_parallel, start: (j) => runTask(j.task, cfg, { plan: j.plan }), onDone: (j, res) => { report(j, res); } });
   log("OwlMem auto-wake " + VERSION + " running on " + (cfg.machine || hostname()) + ".");
+  const usage = () => usageTick(cfg, api, log).catch((e) => log("usage: " + e.message));
+  setTimeout(usage, 30000).unref(); setInterval(usage, USAGE_EVERY).unref();
   const out = await wakeLoop({ cfg, api, sched, log, update: (v) => wakeUpdate(v, { log }),
     cleanup: () => { try { wakeUninstall(autostartOpts(), wakeRunCmd, true); } catch (e) { log("cleanup: " + e.message); } } });
   if (out === "revoked") process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owlmem",
-  "version": "0.7.9",
+  "version": "0.9.0",
   "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" },