carmoji 0.2.0 → 0.3.0

package/README.md

@@ -1,10 +1,13 @@
 # CarMoji Bridge
 
-Forwards coding events from **Claude Code** and **Codex** on your computer
-to the CarMoji pet on your phone, over a WebSocket on the same Wi-Fi.
-The pet wakes up when a session starts, "types" while the agent edits,
-gets nervous while tests run, celebrates finished turns, and pleads with
-big puppy eyes when the agent is waiting for your approval.
+Forwards coding events from **Claude Code, Codex, Gemini CLI, Cursor,
+Qoder, Factory, CodeBuddy, Copilot CLI, Kimi Code CLI, Trae, Qwen Code,
+Cline** and friends on your computer to the CarMoji pet on your phone,
+over a WebSocket on the same Wi-Fi. The pet wakes up when a session
+starts, "types" while the agent edits, pores over a document while it
+reads and searches, gets nervous while tests run, celebrates finished
+turns, and pleads with big puppy eyes when the agent is waiting for your
+approval.
 
 ## Setup (once)
 
@@ -50,19 +53,45 @@ 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
+## All the other tools
 
 ```sh
-npx carmoji install-codex
+npx carmoji tools          # what's supported, what's detected
+npx carmoji install codex  # one tool…
+npx carmoji install all    # …or hooks for everything found on this machine
+npx carmoji uninstall <tool>
 ```
 
-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)).
+| 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 |
+| `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) |
+| `qoder`, `qoderwork` | `~/.qoder{work}/settings.json` | Claude Code forks |
+| `factory` | `~/.factory/settings.json` | sends as source `droid` |
+| `codebuddy` | `~/.codebuddy/settings.json` | Claude Code fork |
+| `qwen` | `~/.qwen/settings.json` | Claude fork, ms timeouts |
+| `copilot` | `~/.copilot/hooks/carmoji.json` | GitHub Copilot CLI |
+| `kimi` | `~/.kimi/config.toml` | TOML `[[hooks]]` blocks |
+| `cline` | `~/Documents/Cline/Hooks/` | one script per event |
+
+Everything merges non-destructively: a backup is written next to each
+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.
+
+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
+agent is working — each with its own colored dot on the dashboard.
+
+Older Codex versions without hooks support can still use
+`npx carmoji install-codex-notify`, which sets the `notify` program in
+`~/.codex/config.toml` (turn completions only). OpenCode users running the
+community **omo** plugin get events for free — omo fires your Claude Code
+hooks, which already carry carmoji.
 
 ## Try it without a coding agent
 

package/carmoji.js

@@ -6,16 +6,20 @@
 //
 // Commands:
 //   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
+//   install <tool>   install hooks for a tool (or `all`); see `tools`
+//   uninstall <tool> remove CarMoji hooks from a tool's config
+//   tools            list supported tools and where their hooks live
+//   hook             hook entry point, all tools (reads hook JSON on stdin;
+//                    --source <tool>, --event <name>, --gate)
+//   codex-notify     legacy Codex notify entry point (event JSON as last arg)
+//   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
+//   codex-config     print the ~/.codex/config.toml notify line (legacy)
 
 import {
   readFileSync, writeFileSync, mkdirSync,
   statSync, openSync, readSync, closeSync,
-  copyFileSync, existsSync, readdirSync,
+  copyFileSync, existsSync, readdirSync, unlinkSync,
 } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
@@ -282,18 +286,120 @@ function claudeUsage(allowRecompute) {
   return usage;
 }
 
-/** Map a Claude Code hook payload to a wire event, or null to ignore. */
-function eventFromClaudeHook(payload) {
-  switch (payload.hook_event_name) {
+/**
+ * Raw hook event name → canonical Claude-style name. The supported tools
+ * speak several dialects — Cursor/Copilot camelCase, Trae CLI and Hermes
+ * snake_case, Gemini's Before/After pairs, Cline's task lifecycle — and
+ * they all fold onto one vocabulary before the wire mapping.
+ */
+const EVENT_ALIASES = {
+  // Cursor / Trae IDE (camelCase). afterFileEdit has no "before" twin, so
+  // it maps to a tool START — a burst of edits reads as continuous typing.
+  beforeSubmitPrompt: 'UserPromptSubmit',
+  beforeShellExecution: 'PreToolUse',
+  afterShellExecution: 'PostToolUse',
+  beforeReadFile: 'PreToolUse',
+  afterFileEdit: 'PreToolUse',
+  beforeMCPExecution: 'PreToolUse',
+  afterMCPExecution: 'PostToolUse',
+  afterAgentThought: 'PostToolUse',
+  afterAgentResponse: 'PostToolUse',
+  stop: 'Stop',
+  // Gemini CLI (its stdin lacks the event name, so these arrive via --event)
+  BeforeTool: 'PreToolUse',
+  AfterTool: 'PostToolUse',
+  BeforeAgent: 'UserPromptSubmit',
+  AfterAgent: 'Stop',
+  // GitHub Copilot CLI (camelCase)
+  sessionStart: 'SessionStart',
+  sessionEnd: 'SessionEnd',
+  userPromptSubmitted: 'UserPromptSubmit',
+  preToolUse: 'PreToolUse',
+  postToolUse: 'PostToolUse',
+  errorOccurred: 'Error',
+  // Cline (task lifecycle)
+  TaskStart: 'SessionStart',
+  TaskResume: 'UserPromptSubmit',
+  TaskComplete: 'Stop',
+  TaskCancel: 'Stop',
+  // snake_case dialects (Trae CLI, Hermes)
+  session_start: 'SessionStart',
+  session_end: 'SessionEnd',
+  user_prompt_submit: 'UserPromptSubmit',
+  pre_tool_use: 'PreToolUse',
+  post_tool_use: 'PostToolUse',
+  post_tool_use_failure: 'Error',
+  permission_request: 'Notification',
+  notification: 'Notification',
+  pre_tool_call: 'PreToolUse',
+  post_tool_call: 'PostToolUse',
+  on_session_start: 'SessionStart',
+  on_session_end: 'SessionEnd',
+};
+
+/** Stand-in tool names for Cursor/Trae events whose payloads name no tool. */
+const EVENT_TOOL_HINTS = {
+  beforeShellExecution: 'Bash',
+  beforeReadFile: 'Read',
+  afterFileEdit: 'Edit',
+  beforeMCPExecution: 'MCP',
+};
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value;
+  }
+  return undefined;
+}
+
+/**
+ * Fold the many stdin dialects onto Claude-style field names
+ * (hook_event_name / session_id / tool_name / tool_input) in place.
+ */
+function normalizePayload(payload, eventFlag) {
+  payload.hook_event_name ??= firstString(
+    payload.hookEventName, payload.eventName, payload.event,
+    payload.hookName, eventFlag);
+  payload.session_id ??= firstString(
+    payload.sessionId, payload.conversation_id, payload.conversationId,
+    payload.taskId);
+  // Copilot: camelCase tool fields, arguments as a JSON string.
+  if (!payload.tool_name && firstString(payload.toolName)) {
+    payload.tool_name = payload.toolName;
+  }
+  if (!payload.tool_input && firstString(payload.toolArgs)) {
+    try { payload.tool_input = JSON.parse(payload.toolArgs); } catch { /* keep raw */ }
+  }
+  // Cline nests tool info under preToolUse / postToolUse.
+  const nested = payload.preToolUse || payload.postToolUse;
+  if (nested && typeof nested === 'object') {
+    payload.tool_name ??= firstString(nested.toolName);
+    payload.tool_input ??= nested.parameters;
+  }
+  return payload;
+}
+
+/** Map a normalized hook payload to a wire event, or null to ignore. */
+function eventFromHook(payload) {
+  const raw = payload.hook_event_name;
+  const tool = payload.tool_name ?? EVENT_TOOL_HINTS[raw];
+  switch (EVENT_ALIASES[raw] ?? raw) {
     case 'SessionStart': return { event: 'session_start' };
     case 'UserPromptSubmit': return { event: 'prompt' };
-    case 'PreToolUse': return { event: 'tool_start', tool: payload.tool_name };
+    case 'PreToolUse': return { event: 'tool_start', tool };
     // tool_end doesn't animate the face; it's a session heartbeat and a
     // fresh token sample for the tok/s readout.
-    case 'PostToolUse': return { event: 'tool_end', tool: payload.tool_name };
+    case 'PostToolUse': return { event: 'tool_end', tool };
+    case 'PostToolUseFailure':
+    case 'Error': return { event: 'error' };
     case 'Notification': return { event: 'permission' };
     case 'Stop': return { event: 'turn_done' };
     case 'SessionEnd': return { event: 'session_end' };
+    // Liveness only: keep the session fresh without a face reaction.
+    case 'SubagentStart':
+    case 'SubagentStop':
+    case 'PreCompact':
+    case 'PostCompact': return { event: 'tool_end' };
     default: return null;
   }
 }
@@ -342,6 +448,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' },
@@ -360,6 +467,302 @@ function backupFile(path) {
 const CLAUDE_HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse',
                             'PostToolUse', 'Notification', 'Stop', 'SessionEnd'];
 
+// ---------------------------------------------------------------------------
+// Multi-tool hook installers (see EVENT_ALIASES for how their events map).
+//
+// Formats, mirroring how each tool reads hooks:
+//   claude  — {matcher, hooks:[{type,command,timeout}]} per PascalCase event
+//             under the config's "hooks" key (Claude Code and its forks)
+//   nested  — {hooks:[{type,command,timeout}]} (Codex hooks.json, Gemini)
+//   flat    — {command} per event (Cursor hooks.json, + top-level version)
+//   trae    — {matcher, loop_limit, hooks:[...]} + top-level version (Trae IDE)
+//   copilot — {type:"command", bash, timeoutSec} + top-level version
+//   kimi    — TOML [[hooks]] blocks appended to config.toml
+//   cline   — one executable script per event in ~/Documents/Cline/Hooks
+// ---------------------------------------------------------------------------
+
+const CURSOR_STYLE_EVENTS = [
+  'beforeSubmitPrompt', 'beforeShellExecution', 'afterShellExecution',
+  'beforeReadFile', 'afterFileEdit', 'beforeMCPExecution', 'afterMCPExecution',
+  'afterAgentThought', 'afterAgentResponse', 'stop',
+];
+
+/**
+ * Every tool `carmoji install <name>` knows. `source` defaults to the key;
+ * `timeoutMs` marks tools whose hook timeouts are milliseconds; `eventFlag`
+ * marks tools whose stdin lacks the event name (the command carries
+ * `--event <name>`); `requiresDir` gates installation on the tool actually
+ * being present.
+ */
+const TOOLS = {
+  claude:    { name: 'Claude Code', format: 'claude', config: '.claude/settings.json' },
+  codex:     { name: 'Codex', format: 'codex' },
+  gemini:    { name: 'Gemini CLI', format: 'nested', config: '.gemini/settings.json',
+               eventFlag: true, timeoutMs: true,
+               events: ['SessionStart', 'SessionEnd', 'BeforeTool', 'AfterTool',
+                        'BeforeAgent', 'AfterAgent'] },
+  cursor:    { name: 'Cursor', format: 'flat', config: '.cursor/hooks.json',
+               versionKey: true, eventFlag: true, events: CURSOR_STYLE_EVENTS },
+  trae:      { name: 'Trae IDE', format: 'trae', config: '.trae/hooks.json',
+               versionKey: true, eventFlag: true, events: CURSOR_STYLE_EVENTS },
+  traecn:    { name: 'Trae CN', format: 'trae', config: '.trae-cn/hooks.json',
+               versionKey: true, eventFlag: true, events: CURSOR_STYLE_EVENTS },
+  qoder:     { name: 'Qoder', format: 'claude', config: '.qoder/settings.json' },
+  qoderwork: { name: 'QoderWork', format: 'claude', config: '.qoderwork/settings.json',
+               note: 'Restart QoderWork for the hooks to take effect.' },
+  factory:   { name: 'Factory (droid)', source: 'droid', format: 'claude',
+               config: '.factory/settings.json' },
+  codebuddy: { name: 'CodeBuddy', format: 'claude', config: '.codebuddy/settings.json' },
+  qwen:      { name: 'Qwen Code', format: 'claude', config: '.qwen/settings.json',
+               timeoutMs: true },
+  copilot:   { name: 'GitHub Copilot CLI', format: 'copilot',
+               config: '.copilot/hooks/carmoji.json', requiresDir: '.copilot',
+               versionKey: true, eventFlag: true,
+               events: ['sessionStart', 'sessionEnd', 'userPromptSubmitted',
+                        'preToolUse', 'postToolUse', 'errorOccurred'] },
+  kimi:      { name: 'Kimi Code CLI', format: 'kimi', config: '.kimi/config.toml',
+               requiresDir: '.kimi',
+               events: ['SessionStart', 'SessionEnd', 'UserPromptSubmit',
+                        'PreToolUse', 'PostToolUse', 'PostToolUseFailure',
+                        'Notification', 'Stop'] },
+  cline:     { name: 'Cline', format: 'cline', config: 'Documents/Cline/Hooks',
+               requiresDir: 'Documents/Cline',
+               events: ['TaskStart', 'TaskResume', 'TaskCancel', 'TaskComplete',
+                        'UserPromptSubmit', 'PreToolUse', 'PostToolUse'] },
+};
+
+/** Resolve Codex's config dir, honoring $CODEX_HOME like Codex itself does. */
+function codexHome() {
+  const raw = (process.env.CODEX_HOME || '').trim();
+  if (!raw) return join(homedir(), '.codex');
+  if (raw === '~') return homedir();
+  if (raw.startsWith('~/')) return join(homedir(), raw.slice(2));
+  return raw;
+}
+
+function isToolPresent(key, tool) {
+  const marker = tool.requiresDir
+    ? join(homedir(), tool.requiresDir)
+    : key === 'codex' ? codexHome()
+    : dirname(join(homedir(), tool.config));
+  return existsSync(marker);
+}
+
+/** Shared JSON read: refuses to touch files that don't parse. */
+function readJsonConfig(path) {
+  if (!existsSync(path)) return {};
+  const text = readFileSync(path, 'utf8');
+  if (!text.trim()) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    console.error(`${path} is not valid JSON — fix it first (nothing was changed).`);
+    process.exit(1);
+  }
+}
+
+function writeConfig(path, text) {
+  const bak = existsSync(path) ? backupFile(path) : null;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+  if (bak) console.log(`Backup saved to ${bak}`);
+}
+
+/** Generic JSON-config installer covering claude/nested/flat/trae/copilot. */
+function installJsonHooks(key, tool) {
+  const path = key === 'codex' ? join(codexHome(), 'hooks.json')
+    : join(homedir(), tool.config);
+  const root = readJsonConfig(path);
+  if (tool.versionKey && root.version === undefined) root.version = 1;
+  const hooks = (root.hooks && typeof root.hooks === 'object' && !Array.isArray(root.hooks))
+    ? root.hooks : {};
+  const source = tool.source ?? key;
+  const base = `${HOOK_COMMAND} --source ${source}`;
+  const timeout = (seconds) => (tool.timeoutMs ? seconds * 1000 : seconds);
+
+  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 command = tool.eventFlag ? `${base} --event ${event}` : base;
+    switch (tool.format) {
+      case 'claude':
+        entries.push({ matcher: '*',
+                       hooks: [{ type: 'command', command, timeout: timeout(5) }] });
+        break;
+      case 'codex':
+      case 'nested':
+        entries.push({ hooks: [{ type: 'command', command, timeout: timeout(5) }] });
+        break;
+      case 'flat':
+        entries.push({ command });
+        break;
+      case 'trae':
+        entries.push({ matcher: '*', loop_limit: 5,
+                       hooks: [{ type: 'command', command, timeout: timeout(5) }] });
+        break;
+      case 'copilot':
+        entries.push({ type: 'command', bash: command, timeoutSec: 5 });
+        break;
+    }
+    hooks[event] = entries;
+  }
+  root.hooks = hooks;
+  writeConfig(path, JSON.stringify(root, null, 2) + '\n');
+  console.log(`Installed CarMoji hooks for ${tool.name} in ${path}`);
+  if (tool.note) console.log(tool.note);
+}
+
+/** Drop [[hooks]] TOML blocks that mention carmoji; keep everything else. */
+function removeKimiBlocks(contents) {
+  const lines = contents.split('\n');
+  const kept = [];
+  let index = 0;
+  while (index < lines.length) {
+    if (lines[index].trim() === '[[hooks]]') {
+      const block = [lines[index]];
+      let next = index + 1;
+      while (next < lines.length && !lines[next].trim().startsWith('[')) {
+        block.push(lines[next]);
+        next += 1;
+      }
+      if (!block.join('\n').includes('carmoji')) kept.push(...block);
+      index = next;
+    } else {
+      kept.push(lines[index]);
+      index += 1;
+    }
+  }
+  while (kept.length && !kept[kept.length - 1].trim()) kept.pop();
+  return kept.join('\n');
+}
+
+/** Kimi Code CLI reads TOML [[hooks]] blocks from ~/.kimi/config.toml. */
+function installKimiHooks(key, tool) {
+  const path = join(homedir(), tool.config);
+  let contents = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  contents = removeKimiBlocks(contents);
+  const command = `${HOOK_COMMAND} --source kimi`.replace(/"/g, '\\"');
+  const blocks = tool.events.map((event) => {
+    const toolEvent = ['PreToolUse', 'PostToolUse', 'PostToolUseFailure'].includes(event);
+    return `[[hooks]]\nevent = "${event}"\ncommand = "${command}"\ntimeout = 5`
+      + (toolEvent ? '\nmatcher = ".*"' : '');
+  });
+  if (contents && !contents.endsWith('\n')) contents += '\n';
+  if (contents) contents += '\n';
+  writeConfig(path, contents + blocks.join('\n\n') + '\n');
+  console.log(`Installed CarMoji hooks for ${tool.name} in ${path}`);
+}
+
+const CLINE_HOOK_MARKER = 'carmoji hook';
+
+/** Cline runs one executable file per event from ~/Documents/Cline/Hooks. */
+function installClineHooks(key, tool) {
+  const dir = join(homedir(), tool.config);
+  mkdirSync(dir, { recursive: true });
+  const script = '#!/bin/sh\n'
+    + '# carmoji hook — forwards Cline events to the CarMoji pet\n'
+    + `exec ${HOOK_COMMAND} --source cline\n`;
+  for (const event of tool.events) {
+    const path = join(dir, event);
+    if (existsSync(path) && !readFileSync(path, 'utf8').includes('carmoji')) {
+      console.log(`Skipped ${path} — another hook already lives there `
+        + '(Cline runs one script per event).');
+      continue;
+    }
+    writeFileSync(path, script, { mode: 0o755 });
+  }
+  console.log(`Installed CarMoji hooks for ${tool.name} in ${dir}`);
+}
+
+/**
+ * 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.
+ */
+function installCodexHooks() {
+  installJsonHooks('codex', {
+    name: 'Codex', format: 'codex',
+    events: ['SessionStart', 'SessionEnd', 'UserPromptSubmit',
+             'PreToolUse', 'PostToolUse', 'Stop'],
+  });
+  const configPath = join(codexHome(), 'config.toml');
+  if (!existsSync(configPath)) return;
+  const text = readFileSync(configPath, 'utf8');
+  const lines = text.split('\n');
+  const notifyIndex = lines.findIndex(
+    (line) => /^\s*notify\s*=/.test(line) && line.includes('carmoji'));
+  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).');
+  }
+}
+
+function installTool(key, { skipMissing = false } = {}) {
+  const tool = TOOLS[key];
+  if (!tool) {
+    console.error(`Unknown tool "${key}". Known: ${Object.keys(TOOLS).join(', ')}`);
+    process.exit(1);
+  }
+  if (!isToolPresent(key, tool)) {
+    console.log(`${tool.name}: not found on this machine — skipped.`);
+    if (!skipMissing) {
+      console.log(`(Looked for ~/${tool.requiresDir
+        ?? (key === 'codex' ? '.codex' : dirname(tool.config))}.)`);
+    }
+    return;
+  }
+  if (key === 'claude') { installClaude(); return; }
+  if (key === 'codex') { installCodexHooks(); return; }
+  if (tool.format === 'kimi') { installKimiHooks(key, tool); return; }
+  if (tool.format === 'cline') { installClineHooks(key, tool); return; }
+  installJsonHooks(key, tool);
+}
+
+function uninstallTool(key) {
+  const tool = TOOLS[key];
+  if (!tool) {
+    console.error(`Unknown tool "${key}". Known: ${Object.keys(TOOLS).join(', ')}`);
+    process.exit(1);
+  }
+  if (tool.format === 'cline') {
+    const dir = join(homedir(), tool.config);
+    for (const event of tool.events) {
+      const path = join(dir, event);
+      if (existsSync(path) && readFileSync(path, 'utf8').includes('carmoji')) {
+        try { unlinkSync(path); } catch { /* leave it */ }
+      }
+    }
+    console.log(`Removed CarMoji hooks for ${tool.name}.`);
+    return;
+  }
+  if (tool.format === 'kimi') {
+    const path = join(homedir(), tool.config);
+    if (existsSync(path)) {
+      writeConfig(path, removeKimiBlocks(readFileSync(path, 'utf8')) + '\n');
+    }
+    console.log(`Removed CarMoji hooks for ${tool.name}.`);
+    return;
+  }
+  const path = key === 'codex' ? join(codexHome(), 'hooks.json')
+    : join(homedir(), tool.config);
+  if (!existsSync(path)) { console.log(`${tool.name}: nothing installed.`); return; }
+  const root = readJsonConfig(path);
+  if (root.hooks && typeof root.hooks === 'object') {
+    for (const [event, value] of Object.entries(root.hooks)) {
+      if (!Array.isArray(value)) continue;
+      const kept = value.filter((entry) => !JSON.stringify(entry).includes('carmoji'));
+      if (kept.length) root.hooks[event] = kept;
+      else delete root.hooks[event];
+    }
+  }
+  writeConfig(path, JSON.stringify(root, null, 2) + '\n');
+  console.log(`Removed CarMoji hooks for ${tool.name} from ${path}`);
+}
+
 /** Merge the CarMoji hooks into ~/.claude/settings.json, keeping a backup. */
 function installClaude() {
   const path = join(homedir(), '.claude', 'settings.json');
@@ -394,9 +797,10 @@ function installClaude() {
   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');
+/** Legacy: set the CarMoji notify program in ~/.codex/config.toml (older
+ *  Codex versions without hooks.json support), keeping a backup. */
+function installCodexNotify() {
+  const path = join(codexHome(), 'config.toml');
   const notifyLine = RUNNING_FROM_PACKAGE
     ? 'notify = ["npx", "-y", "carmoji", "codex-notify"]'
     : `notify = ["node", "${SCRIPT_PATH}", "codex-notify"]`;
@@ -474,19 +878,28 @@ async function main() {
     }
 
     case 'hook': {
-      // Runs inside Claude Code on every hook — must be silent, quick, and
-      // always exit 0 so it can never disturb the session.
+      // Runs inside the coding agent on every hook — must be silent, quick,
+      // and always exit 0 so it can never disturb the session.
+      // Flags: --source <tool> (default claude), --event <name> for tools
+      // whose stdin lacks the event name, --gate for phone approvals.
       try {
         const config = loadConfig();
         if (!config) break;
-        const payload = JSON.parse(readStdin() || '{}');
+        const flags = [arg, ...rest].filter(Boolean);
+        const flagValue = (name) => {
+          const index = flags.indexOf(name);
+          return index >= 0 ? flags[index + 1] : undefined;
+        };
+        const source = flagValue('--source') || 'claude';
+        const payload = normalizePayload(JSON.parse(readStdin() || '{}'),
+                                         flagValue('--event'));
 
         // Gate mode (opt-in, see `gate-config`): PreToolUse blocks while
         // the phone shows Allow/Deny; the printed JSON settles the
         // permission. Timeout falls through to the normal terminal prompt.
-        if (arg === '--gate' && payload.hook_event_name === 'PreToolUse') {
+        if (flags.includes('--gate') && payload.hook_event_name === 'PreToolUse') {
           const decision = await requestApproval(config, {
-            source: 'claude',
+            source,
             session: payload.session_id,
             event: 'approval_request',
             tool: payload.tool_name,
@@ -507,21 +920,32 @@ async function main() {
           break;
         }
 
-        const event = eventFromClaudeHook(payload);
+        const event = eventFromHook(payload);
         if (!event) break;
-        const message = { source: 'claude', session: payload.session_id, ...event };
+        const message = { source, session: payload.session_id, ...event };
+        // Claude-format transcripts power the tok/s readout; the forks share
+        // the format, and sessionTokens quietly no-ops for everyone else.
         const tokens = sessionTokens(payload);
         if (tokens !== undefined) message.tokens = tokens;
-        if (payload.cwd) message.project = basename(payload.cwd);
+        // Gemini and Trae hooks carry no cwd — the hook itself runs in the
+        // project directory, so fall back to that.
+        const cwd = payload.cwd || process.cwd();
+        if (cwd) message.project = basename(cwd);
         // A snippet of human-readable context for the phone to show.
-        const detail = payload.hook_event_name === 'UserPromptSubmit' ? payload.prompt
-          : payload.hook_event_name === 'Notification' ? payload.message
-          : undefined;
+        const detail = event.event === 'prompt'
+          ? firstString(payload.prompt, payload.user_prompt, payload.userPrompt,
+                        payload.message, payload.input, payload.text)
+          : event.event === 'permission'
+            ? firstString(payload.message, payload.detail)
+            : 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;
+        // Plan-window usage comes from Claude Code's local transcripts;
+        // recompute only at turn boundaries.
+        if (source === 'claude') {
+          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.
@@ -580,12 +1004,50 @@ async function main() {
       break;
     }
 
+    case 'install': {
+      if (arg === 'all') {
+        for (const key of Object.keys(TOOLS)) {
+          installTool(key, { skipMissing: true });
+        }
+        break;
+      }
+      if (!arg) {
+        console.log(`Usage: carmoji install <tool>|all\nTools: ${Object.keys(TOOLS).join(', ')}`);
+        process.exit(1);
+      }
+      installTool(arg);
+      break;
+    }
+
+    case 'uninstall': {
+      if (!arg) {
+        console.log(`Usage: carmoji uninstall <tool>\nTools: ${Object.keys(TOOLS).join(', ')}`);
+        process.exit(1);
+      }
+      uninstallTool(arg);
+      break;
+    }
+
+    case 'tools': {
+      console.log('Supported tools (carmoji install <tool>):');
+      for (const [key, tool] of Object.entries(TOOLS)) {
+        const where = key === 'codex' ? '$CODEX_HOME/hooks.json' : `~/${tool.config}`;
+        const found = isToolPresent(key, tool) ? '' : '  (not detected)';
+        console.log(`  ${key.padEnd(10)} ${tool.name.padEnd(20)} ${where}${found}`);
+      }
+      break;
+    }
+
     case 'install-claude':
       installClaude();
       break;
 
     case 'install-codex':
-      installCodex();
+      installCodexHooks();
+      break;
+
+    case 'install-codex-notify':
+      installCodexNotify();
       break;
 
     case 'claude-config':
@@ -595,7 +1057,9 @@ async function main() {
       break;
 
     case 'codex-config':
-      console.log('Add this line to ~/.codex/config.toml:\n');
+      console.log('Modern Codex reads hooks from $CODEX_HOME/hooks.json — prefer:');
+      console.log('  carmoji install codex\n');
+      console.log('For older Codex versions, add this line to ~/.codex/config.toml:\n');
       console.log(RUNNING_FROM_PACKAGE
         ? 'notify = ["npx", "-y", "carmoji", "codex-notify"]'
         : `notify = ["node", "${SCRIPT_PATH}", "codex-notify"]`);
@@ -617,7 +1081,7 @@ async function main() {
       break;
 
     default:
-      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');
+      console.log('carmoji bridge — usage: pair <code> [ip[:port]] | discover | install <tool>|all | uninstall <tool> | tools | test <event> | hook [--source <tool>] [--event <name>] [--gate] | codex-notify | claude-config | codex-config | gate-config');
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carmoji",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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": {