carmoji 0.1.0 → 0.2.1

package/README.md

@@ -39,22 +39,30 @@ big puppy eyes when the agent is waiting for your approval.
 
 Coding in *this* repo works out of the box — the hooks ship in
 [.claude/settings.json](../.claude/settings.json). To get reactions in
-every project, print the snippet and merge it into `~/.claude/settings.json`:
+every project:
 
 ```sh
-npx carmoji claude-config
+npx carmoji install-claude
 ```
 
+merges the hooks into `~/.claude/settings.json`, preserving everything
+already there (a backup is saved to `settings.json.bak` first, reruns are
+no-ops, and a file that doesn't parse is refused untouched). Prefer to do
+it by hand? `npx carmoji claude-config` prints the snippet instead.
+
 ## Codex
 
 ```sh
-npx carmoji codex-config
+npx carmoji install-codex
 ```
 
-prints the `notify = [...]` line for `~/.codex/config.toml`. Codex's notify
-surface only reports completed turns, so the pet celebrates finished work
-but doesn't see individual edits (tail `~/.codex/sessions/` is a possible
-future upgrade — see [docs/ROADMAP.md](../docs/ROADMAP.md)).
+sets the `notify` program in `~/.codex/config.toml` (backup to
+`config.toml.bak`; an existing notify line is replaced with a printed
+warning). `npx carmoji codex-config` prints the line if you'd rather paste
+it yourself. Codex's notify surface only reports completed turns, so the
+pet celebrates finished work but doesn't see individual edits (tail
+`~/.codex/sessions/` is a possible future upgrade — see
+[docs/ROADMAP.md](../docs/ROADMAP.md)).
 
 ## Try it without a coding agent
 
@@ -91,6 +99,15 @@ dot while agents are live, and GPS pauses to save battery. Prompt snippets
 and permission messages (first ~140 chars) are sent to the phone as brief
 toasts; they stay on your LAN and are only accepted by the paired device.
 
+## Plan-window usage
+
+The buddy dashboard's corner shows your rolling **5-hour and 7-day token
+totals** ("5H 2.5M / 7D 13.7M"), summed from the local Claude Code
+transcripts the same way community usage tools do (input + output +
+cache-write tokens; cache reads excluded). It's your real consumption, not
+an official percentage of plan quota — there's no public API for that.
+Recomputed at turn boundaries with a 5-minute cache so hooks stay fast.
+
 ## Answer permissions from the phone (Claude Code, opt-in)
 
 ```sh

package/carmoji.js

@@ -8,13 +8,14 @@
 //   pair <code>      discover the phone on this Wi-Fi and pair with it
 //   hook             Claude Code hook entry point (reads hook JSON on stdin)
 //   codex-notify     Codex notify entry point (event JSON as last argument)
-//   test <name>      send a test event: start|prompt|edit|run|done|error|permission|end
+//   test <name>      send a test event: start|prompt|edit|read|run|heartbeat|done|error|permission|end
 //   claude-config    print the .claude/settings.json hooks snippet
 //   codex-config     print the ~/.codex/config.toml notify line
 
 import {
   readFileSync, writeFileSync, mkdirSync,
   statSync, openSync, readSync, closeSync,
+  copyFileSync, existsSync, readdirSync,
 } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
@@ -222,6 +223,65 @@ function summarizeToolInput(payload) {
   return String(text).replace(/\s+/g, ' ').slice(0, 140);
 }
 
+/**
+ * Rolling 5-hour / 7-day token totals summed from the local Claude Code
+ * transcripts — the same data community usage tools read. Counts input,
+ * output, and cache-write tokens (cache reads are nearly free and would
+ * drown the numbers). Cached for 5 minutes because a full scan reads a
+ * week of JSONL; only turn boundaries may recompute — per-tool hooks just
+ * reuse the cache so they stay fast.
+ */
+function claudeUsage(allowRecompute) {
+  const cachePath = join(dirname(CONFIG_PATH), 'usage-cache.json');
+  try {
+    const cached = JSON.parse(readFileSync(cachePath, 'utf8'));
+    if (!allowRecompute || Date.now() - cached.computedAt < 300_000) {
+      return cached.usage;
+    }
+  } catch {
+    if (!allowRecompute) return undefined;
+  }
+  const now = Date.now();
+  const h5cut = now - 5 * 3600e3;
+  const d7cut = now - 7 * 86400e3;
+  let h5 = 0;
+  let d7 = 0;
+  const stack = [join(homedir(), '.claude', 'projects')];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) { stack.push(path); continue; }
+      if (!entry.name.endsWith('.jsonl')) continue;
+      try {
+        if (statSync(path).mtimeMs < d7cut) continue;
+        for (const line of readFileSync(path, 'utf8').split('\n')) {
+          if (!line.includes('"usage"')) continue;
+          try {
+            const record = JSON.parse(line);
+            const usage = record.message?.usage;
+            if (!usage) continue;
+            const ts = Date.parse(record.timestamp);
+            if (!(ts >= d7cut)) continue;
+            const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0)
+              + (usage.cache_creation_input_tokens || 0);
+            d7 += tokens;
+            if (ts >= h5cut) h5 += tokens;
+          } catch { /* skip malformed lines */ }
+        }
+      } catch { /* unreadable file */ }
+    }
+  }
+  const usage = { h5, d7 };
+  try {
+    mkdirSync(dirname(cachePath), { recursive: true });
+    writeFileSync(cachePath, JSON.stringify({ computedAt: now, usage }));
+  } catch { /* cache is best-effort */ }
+  return usage;
+}
+
 /** Map a Claude Code hook payload to a wire event, or null to ignore. */
 function eventFromClaudeHook(payload) {
   switch (payload.hook_event_name) {
@@ -282,6 +342,7 @@ const TEST_EVENTS = {
   start: { event: 'session_start' },
   prompt: { event: 'prompt' },
   edit: { event: 'tool_start', tool: 'Edit' },
+  read: { event: 'tool_start', tool: 'Read' },
   run: { event: 'tool_start', tool: 'Bash' },
   heartbeat: { event: 'tool_end', tool: 'Edit' },
   done: { event: 'turn_done' },
@@ -290,6 +351,80 @@ const TEST_EVENTS = {
   end: { event: 'session_end' },
 };
 
+/** Copy `path` to `path.bak` before modifying it; returns the backup path. */
+function backupFile(path) {
+  const bak = `${path}.bak`;
+  copyFileSync(path, bak);
+  return bak;
+}
+
+const CLAUDE_HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse',
+                            'PostToolUse', 'Notification', 'Stop', 'SessionEnd'];
+
+/** Merge the CarMoji hooks into ~/.claude/settings.json, keeping a backup. */
+function installClaude() {
+  const path = join(homedir(), '.claude', 'settings.json');
+  let settings = {};
+  if (existsSync(path)) {
+    try {
+      settings = JSON.parse(readFileSync(path, 'utf8'));
+    } catch {
+      console.error(`${path} is not valid JSON — fix it first (nothing was changed).`);
+      process.exit(1);
+    }
+  }
+  if (typeof settings.hooks !== 'object' || settings.hooks === null) settings.hooks = {};
+
+  let added = 0;
+  for (const name of CLAUDE_HOOK_EVENTS) {
+    const entries = Array.isArray(settings.hooks[name]) ? settings.hooks[name]
+      : (settings.hooks[name] = []);
+    if (JSON.stringify(entries).includes('carmoji')) continue; // already ours
+    entries.push({ hooks: [{ type: 'command', command: HOOK_COMMAND, timeout: 5 }] });
+    added++;
+  }
+  if (added === 0) {
+    console.log(`CarMoji hooks already installed in ${path}`);
+    return;
+  }
+  const bak = existsSync(path) ? backupFile(path) : null;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + '\n');
+  console.log(`Added CarMoji hooks to ${added} event(s) in ${path}`);
+  if (bak) console.log(`Backup saved to ${bak}`);
+  console.log('New Claude Code sessions will pick them up.');
+}
+
+/** Set the CarMoji notify program in ~/.codex/config.toml, keeping a backup. */
+function installCodex() {
+  const path = join(homedir(), '.codex', 'config.toml');
+  const notifyLine = RUNNING_FROM_PACKAGE
+    ? 'notify = ["npx", "-y", "carmoji", "codex-notify"]'
+    : `notify = ["node", "${SCRIPT_PATH}", "codex-notify"]`;
+
+  let text = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  const lines = text.split('\n');
+  const notifyIndex = lines.findIndex((line) => /^\s*notify\s*=/.test(line));
+
+  if (notifyIndex >= 0 && lines[notifyIndex].includes('carmoji')) {
+    console.log(`CarMoji notify already installed in ${path}`);
+    return;
+  }
+  const bak = text ? backupFile(path) : null;
+  if (notifyIndex >= 0) {
+    console.log(`Replacing existing notify: ${lines[notifyIndex].trim()}`);
+    lines[notifyIndex] = notifyLine;
+    text = lines.join('\n');
+  } else {
+    // notify is a top-level key, so it must sit before any [section].
+    text = `${notifyLine}\n${text}`;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text.endsWith('\n') ? text : `${text}\n`);
+  console.log(`Installed CarMoji notify in ${path}`);
+  if (bak) console.log(`Backup saved to ${bak}`);
+}
+
 function claudeConfigSnippet() {
   const entry = [{ hooks: [{ type: 'command', command: HOOK_COMMAND, timeout: 5 }] }];
   const hooks = {};
@@ -384,6 +519,10 @@ async function main() {
           : payload.hook_event_name === 'Notification' ? payload.message
           : undefined;
         if (detail) message.detail = String(detail).replace(/\s+/g, ' ').slice(0, 140);
+        // Plan-window usage: recompute only at turn boundaries.
+        const recompute = ['SessionStart', 'Stop'].includes(payload.hook_event_name);
+        const usage = claudeUsage(recompute);
+        if (usage) message.usage = usage;
         await send(config, message);
       } catch {
         // Never surface errors into the coding session.
@@ -423,6 +562,8 @@ async function main() {
       const message = { source: 'test', session, ...event };
       if (tokens !== undefined) message.tokens = Number(tokens);
       if (project) message.project = project;
+      const usage = claudeUsage(true);
+      if (usage) message.usage = usage;
       const result = await send(config, message);
       console.log(result === 'ok' ? 'Sent!' : `Failed: ${result}`);
       process.exit(result === 'ok' ? 0 : 1);
@@ -440,8 +581,17 @@ async function main() {
       break;
     }
 
+    case 'install-claude':
+      installClaude();
+      break;
+
+    case 'install-codex':
+      installCodex();
+      break;
+
     case 'claude-config':
       console.log('Merge this into the project’s .claude/settings.json (or ~/.claude/settings.json for everywhere):\n');
+      console.log('(Or let `carmoji install-claude` do it for you, with a backup.)\n');
       console.log(claudeConfigSnippet());
       break;
 
@@ -468,7 +618,7 @@ async function main() {
       break;
 
     default:
-      console.log('carmoji bridge — usage: pair <code> [ip[:port]] | discover | test <event> | hook [--gate] | codex-notify | claude-config | codex-config | gate-config');
+      console.log('carmoji bridge — usage: pair <code> [ip[:port]] | discover | install-claude | install-codex | test <event> | hook [--gate] | codex-notify | claude-config | codex-config | gate-config');
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carmoji",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Bring your CarMoji pet to life from Claude Code / Codex — a LAN bridge that streams coding events to the CarMoji iOS app",
   "type": "module",
   "bin": {