carmoji 0.3.1 → 0.3.2

package/README.md

@@ -65,7 +65,7 @@ npx carmoji uninstall <tool>
 | Tool | Hooks written to | Notes |
 | --- | --- | --- |
 | `claude` | `~/.claude/settings.json` | full event coverage |
-| `codex` | `$CODEX_HOME/hooks.json` | full lifecycle via Codex hooks; replaces the old notify line |
+| `codex` | `$CODEX_HOME/hooks.json` | turn, tool, and permission events via Codex hooks |
 | `gemini` | `~/.gemini/settings.json` | Before/After tool + agent events |
 | `cursor` | `~/.cursor/hooks.json` | shell/read/edit/MCP events |
 | `trae`, `traecn` | `~/.trae{,-cn}/hooks.json` | Trae IDE (Cursor-style events) |
@@ -82,6 +82,11 @@ config, reruns are idempotent, only carmoji-owned entries are ever
 removed, and unparseable files are refused untouched. `install all` skips
 tools that aren't on the machine.
 
+Codex requires new or changed command hooks to be trusted. After installing,
+open `/hooks` in Codex, review the CarMoji commands, and trust them. The
+installer removes a direct legacy CarMoji `notify` command, or removes only
+CarMoji when another notifier has it chained via `--previous-notify`.
+
 All of them funnel through the same `carmoji hook` entry point
 (`--source` names the tool, `--event` supplies the event name for tools
 whose payloads lack one), so the pet reacts identically no matter which
@@ -112,11 +117,15 @@ npx carmoji test end         # contented sigh
   but if one agent is still blocked waiting for your approval, it returns
   to the pleading face after another agent's reaction — and stops pleading
   as soon as the blocked session moves again.
-- The bridge counts each session's cumulative output tokens by tailing the
-  transcript incrementally (per-session byte offsets in
+- The bridge counts each session's cumulative output tokens by tailing Claude
+  message-usage records or Codex `token_count` records incrementally
+  (per-session byte offsets in
   `~/.config/carmoji/sessions/`). While in buddy mode, the dashboard's
   speed readout switches from km/h to **tok/s** — combined across all
-  agents — with the active agent count below it.
+  agents — with the active agent count below it. Codex samples arrive at hook
+  boundaries rather than for every streamed token, so its tok/s value is an
+  approximation. Codex documents its transcript format as unstable; unknown
+  future formats safely fall back to the working-time display.
 
 ## What the phone shows
 
@@ -151,16 +160,16 @@ permission on the computer via the hook's official decision output. No
 answer within ~55 s falls through to the normal terminal prompt.
 
 Honest limits: this decides *tool permissions* only — hooks expose no way
-to answer AskUserQuestion option pickers — and Codex's notify surface has
-no decision channel at all, so it stays display-only.
+to answer AskUserQuestion option pickers — and the Codex integration currently
+treats `PermissionRequest` as display-only.
 
 ## How it works
 
 - The app runs an `NWListener` WebSocket server on port 8737, advertised
   via Bonjour as `_carmoji._tcp`. LAN only; every frame must carry the
   pairing code.
-- `carmoji.js hook` is invoked by Claude Code's hooks with the event JSON
-  on stdin, maps it to a wire event, sends one frame (≤0.9 s budget), and
+- `carmoji.js hook` is invoked by the coding agent's hooks with event JSON on
+  stdin, maps it to a wire event, sends one frame (≤0.9 s budget), and
   always exits 0 — it can never slow down or break a coding session. When
   unpaired it exits immediately.
 - Pairing state lives in `~/.config/carmoji/config.json`.

package/carmoji.js

@@ -19,7 +19,7 @@
 import {
   readFileSync, writeFileSync, mkdirSync,
   statSync, openSync, readSync, closeSync,
-  copyFileSync, existsSync, readdirSync, unlinkSync,
+  copyFileSync, existsSync, readdirSync, unlinkSync, realpathSync,
 } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { homedir, hostname } from 'node:os';
@@ -329,7 +329,7 @@ const EVENT_ALIASES = {
   pre_tool_use: 'PreToolUse',
   post_tool_use: 'PostToolUse',
   post_tool_use_failure: 'Error',
-  permission_request: 'Notification',
+  permission_request: 'PermissionRequest',
   notification: 'Notification',
   pre_tool_call: 'PreToolUse',
   post_tool_call: 'PostToolUse',
@@ -392,7 +392,8 @@ function eventFromHook(payload) {
     case 'PostToolUse': return { event: 'tool_end', tool };
     case 'PostToolUseFailure':
     case 'Error': return { event: 'error' };
-    case 'Notification': return { event: 'permission' };
+    case 'PermissionRequest':
+    case 'Notification': return { event: 'permission', tool };
     case 'Stop': return { event: 'turn_done' };
     case 'SessionEnd': return { event: 'session_end' };
     // Liveness only: keep the session fresh without a face reaction.
@@ -404,10 +405,35 @@ function eventFromHook(payload) {
   }
 }
 
+/** Fold one transcript record into a session's monotonic output-token total.
+ * Claude records per-message deltas; Codex token_count records carry a
+ * cumulative total. `codexReported` lets us convert that total to a delta and
+ * also handles a future reset without making the dashboard count backwards.
+ */
+function applyTranscriptTokenRecord(state, record) {
+  const claudeOutput = record?.message?.usage?.output_tokens;
+  if (Number.isFinite(claudeOutput) && claudeOutput >= 0) {
+    state.total += claudeOutput;
+  }
+
+  const codexOutput = record?.payload?.type === 'token_count'
+    ? record.payload.info?.total_token_usage?.output_tokens
+    : undefined;
+  if (Number.isFinite(codexOutput) && codexOutput >= 0) {
+    const previous = Number.isFinite(state.codexReported)
+      ? state.codexReported : 0;
+    state.total += codexOutput >= previous
+      ? codexOutput - previous
+      : codexOutput;
+    state.codexReported = codexOutput;
+  }
+  return state;
+}
+
 /**
  * Cumulative output tokens for this session, counted incrementally from the
- * transcript JSONL: a per-session byte offset is cached so each hook only
- * parses lines appended since the previous one.
+ * Claude or Codex transcript JSONL. A per-session byte offset is cached so
+ * each hook only parses lines appended since the previous one.
  */
 function sessionTokens(payload) {
   const transcript = payload.transcript_path;
@@ -416,6 +442,8 @@ function sessionTokens(payload) {
   const statePath = join(dirname(CONFIG_PATH), 'sessions', `${session}.json`);
   let state = { offset: 0, total: 0 };
   try { state = JSON.parse(readFileSync(statePath, 'utf8')); } catch {}
+  if (!Number.isFinite(state.offset) || state.offset < 0) state.offset = 0;
+  if (!Number.isFinite(state.total) || state.total < 0) state.total = 0;
   let size;
   try { size = statSync(transcript).size; } catch { return undefined; }
   if (size < state.offset) state = { offset: 0, total: 0 }; // truncated/rotated
@@ -430,10 +458,9 @@ function sessionTokens(payload) {
     const lastNewline = chunk.lastIndexOf(0x0a);
     if (lastNewline >= 0) {
       for (const line of chunk.subarray(0, lastNewline + 1).toString('utf8').split('\n')) {
-        if (!line.includes('"usage"')) continue;
+        if (!line.includes('"usage"') && !line.includes('"token_count"')) continue;
         try {
-          const usage = JSON.parse(line)?.message?.usage;
-          if (usage?.output_tokens) state.total += usage.output_tokens;
+          applyTranscriptTokenRecord(state, JSON.parse(line));
         } catch { /* ignore malformed lines */ }
       }
       state.offset += lastNewline + 1;
@@ -580,9 +607,18 @@ function installJsonHooks(key, tool) {
   const base = `${HOOK_COMMAND} --source ${source}`;
   const timeout = (seconds) => (tool.timeoutMs ? seconds * 1000 : seconds);
 
+  // Remove every old CarMoji entry first, including events no longer in this
+  // tool's supported set. This keeps upgrades idempotent when an event is
+  // renamed or removed (for example Codex's old SessionEnd entry).
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    const kept = value.filter((entry) => !JSON.stringify(entry).includes('carmoji'));
+    if (kept.length) hooks[event] = kept;
+    else delete hooks[event];
+  }
+
   for (const event of tool.events ?? CLAUDE_HOOK_EVENTS) {
-    const entries = (Array.isArray(hooks[event]) ? hooks[event] : [])
-      .filter((entry) => !JSON.stringify(entry).includes('carmoji'));
+    const entries = Array.isArray(hooks[event]) ? hooks[event] : [];
     const command = tool.eventFlag ? `${base} --event ${event}` : base;
     switch (tool.format) {
       case 'claude':
@@ -674,31 +710,100 @@ function installClineHooks(key, tool) {
   console.log(`Installed CarMoji hooks for ${tool.name} in ${dir}`);
 }
 
+function isCarMojiNotifyCommand(args) {
+  if (!Array.isArray(args)) return false;
+  const hasSubcommand = args.includes('codex-notify');
+  const hasEntrypoint = args.some((arg) => typeof arg === 'string'
+    && (arg === 'carmoji' || /(^|[\\/])carmoji\.js$/i.test(arg)));
+  return hasSubcommand && hasEntrypoint;
+}
+
+/** Remove a direct or --previous-notify-nested CarMoji command. */
+function stripCarMojiNotifyCommand(args, depth = 0) {
+  if (!Array.isArray(args) || depth > 8) return { args, changed: false };
+  if (isCarMojiNotifyCommand(args)) return { args: null, changed: true };
+
+  const next = [...args];
+  let changed = false;
+  for (let index = 0; index < next.length - 1; index += 1) {
+    if (next[index] !== '--previous-notify' || typeof next[index + 1] !== 'string') {
+      continue;
+    }
+    let previous;
+    try { previous = JSON.parse(next[index + 1]); } catch { continue; }
+    const stripped = stripCarMojiNotifyCommand(previous, depth + 1);
+    if (!stripped.changed) continue;
+    changed = true;
+    if (stripped.args === null) {
+      next.splice(index, 2);
+      index -= 1;
+    } else {
+      next[index + 1] = JSON.stringify(stripped.args);
+    }
+  }
+  return { args: next, changed };
+}
+
+/**
+ * Remove CarMoji from a single-line TOML `notify = [...]` assignment without
+ * deleting an outer notifier that happens to chain CarMoji. The arrays we
+ * emit (and the notifier wrappers used by Codex integrations) are JSON-compatible.
+ */
+function stripLegacyCarMojiNotifyLine(line) {
+  const match = line.match(/^(\s*notify\s*=\s*)(\[.*\])(\s*(?:#.*)?)$/);
+  if (!match) return { line, changed: false, removed: false };
+  let args;
+  try { args = JSON.parse(match[2]); } catch {
+    return { line, changed: false, removed: false };
+  }
+  const stripped = stripCarMojiNotifyCommand(args);
+  if (!stripped.changed) return { line, changed: false, removed: false };
+  if (stripped.args === null) return { line: null, changed: true, removed: true };
+  return {
+    line: `${match[1]}${JSON.stringify(stripped.args)}${match[3]}`,
+    changed: true,
+    removed: false,
+  };
+}
+
 /**
  * Codex: hooks.json in $CODEX_HOME (Claude-style events, nested entries).
- * The legacy `notify` line only reported finished turns; hooks.json covers
- * the full lifecycle, so a carmoji notify line is removed to avoid double
- * turn_done events. `install-codex-notify` remains for older Codex versions.
+ * The legacy `notify` command only reported finished turns; hooks.json covers
+ * turn, tool, and permission events, so the CarMoji notify command is removed
+ * to avoid double turn_done events. Other chained notifiers are preserved.
  */
 function installCodexHooks() {
   installJsonHooks('codex', {
     name: 'Codex', format: 'codex',
-    events: ['SessionStart', 'SessionEnd', 'UserPromptSubmit',
-             'PreToolUse', 'PostToolUse', 'Stop'],
+    events: ['SessionStart', 'UserPromptSubmit', 'PreToolUse',
+             'PermissionRequest', 'PostToolUse', 'Stop'],
   });
   const configPath = join(codexHome(), 'config.toml');
-  if (!existsSync(configPath)) return;
+  if (!existsSync(configPath)) {
+    console.log('Open /hooks in Codex to review and trust the new hook commands.');
+    return;
+  }
   const text = readFileSync(configPath, 'utf8');
   const lines = text.split('\n');
-  const notifyIndex = lines.findIndex(
-    (line) => /^\s*notify\s*=/.test(line) && line.includes('carmoji'));
+  const notifyIndex = lines.findIndex((line) => /^\s*notify\s*=/.test(line));
   if (notifyIndex >= 0) {
-    backupFile(configPath);
-    lines.splice(notifyIndex, 1);
-    writeFileSync(configPath, lines.join('\n'));
-    console.log(`Removed the legacy carmoji notify line from ${configPath}`);
-    console.log('(hooks.json now covers turn completion — no double events).');
+    const stripped = stripLegacyCarMojiNotifyLine(lines[notifyIndex]);
+    if (stripped.changed) {
+      backupFile(configPath);
+      if (stripped.line === null) lines.splice(notifyIndex, 1);
+      else lines[notifyIndex] = stripped.line;
+      writeFileSync(configPath, lines.join('\n'));
+      console.log(stripped.removed
+        ? `Removed the legacy CarMoji notify line from ${configPath}`
+        : `Removed legacy CarMoji from the chained notifier in ${configPath}`);
+      console.log('(hooks.json now covers turn completion — no double events).');
+    } else if (lines[notifyIndex].includes('carmoji')
+               && lines[notifyIndex].includes('codex-notify')) {
+      console.log(`Left the legacy CarMoji notify unchanged in ${configPath}`);
+      console.log('(its TOML shape was not safely editable; remove only the CarMoji command to avoid duplicate turn-complete events).');
+    }
   }
+  console.log('Open /hooks in Codex to review and trust the new hook commands.');
 }
 
 function installTool(key, { skipMissing = false } = {}) {
@@ -903,8 +1008,8 @@ async function main() {
         // sum across them instead of showing whichever reported last.
         const message = { source, session: payload.session_id,
                           host: hostname(), ...event };
-        // Claude-format transcripts power the tok/s readout; the forks share
-        // the format, and sessionTokens quietly no-ops for everyone else.
+        // Claude and Codex transcripts power the tok/s readout; other formats
+        // quietly produce no token changes.
         const tokens = sessionTokens(payload);
         if (tokens !== undefined) message.tokens = tokens;
         // Gemini and Trae hooks carry no cwd — the hook itself runs in the
@@ -916,7 +1021,8 @@ async function main() {
           ? firstString(payload.prompt, payload.user_prompt, payload.userPrompt,
                         payload.message, payload.input, payload.text)
           : event.event === 'permission'
-            ? firstString(payload.message, payload.detail)
+            ? firstString(payload.message, payload.detail,
+                          payload.tool_input ? summarizeToolInput(payload) : undefined)
             : undefined;
         if (detail) message.detail = String(detail).replace(/\s+/g, ' ').slice(0, 140);
         // Plan-window usage comes from Claude Code's local transcripts;
@@ -1065,4 +1171,21 @@ async function main() {
   }
 }
 
-main().then(() => process.exit(process.exitCode ?? 0));
+export {
+  applyTranscriptTokenRecord,
+  eventFromHook,
+  stripLegacyCarMojiNotifyLine,
+};
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(SCRIPT_PATH);
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  main().then(() => process.exit(process.exitCode ?? 0));
+}

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "carmoji",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "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": {
     "carmoji": "./carmoji.js"
   },
+  "scripts": {
+    "test": "node --test"
+  },
   "files": [
     "carmoji.js",
     "README.md"