carmoji 0.3.1 → 0.3.3

package/README.md

@@ -38,6 +38,12 @@ approval.
    through the system's `dns-sd`, which handles Macs full of VPN tunnels
    and virtual interfaces; other platforms use a JS mDNS fallback.
 
+   Pairing is additive: pair again with a second phone and every event
+   fans out to all paired devices (approval requests go to all of them
+   too — the first tap wins). When devices are already paired, `pair`
+   asks whether to keep them. `npx carmoji unpair` forgets a device —
+   by name or address, or `unpair all` for a clean slate.
+
 ## Claude Code
 
 Coding in *this* repo works out of the box — the hooks ship in
@@ -65,7 +71,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 +88,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 +123,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 +166,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

@@ -6,6 +6,8 @@
 //
 // Commands:
 //   pair <code>      discover the phone on this Wi-Fi and pair with it
+//                    (pairing is additive — events fan out to every device)
+//   unpair [device]  forget a paired device by name or ip[:port], or `all`
 //   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
@@ -19,7 +21,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';
@@ -52,6 +54,30 @@ function saveConfig(config) {
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
 }
 
+/**
+ * Paired devices from a config of either vintage: the original single
+ * top-level {host, port, code}, or the current {devices: [{name, host,
+ * port, code}, …]}. Saving always writes the multi-device shape.
+ */
+function normalizeDevices(config) {
+  if (!config) return [];
+  const list = Array.isArray(config.devices) ? config.devices
+    : config.host ? [config] : [];
+  return list.filter((d) => d && d.host && d.port && d.code);
+}
+
+function loadDevices() {
+  return normalizeDevices(loadConfig());
+}
+
+function saveDevices(devices) {
+  saveConfig({ devices });
+}
+
+function deviceLabel(device) {
+  return `${device.name ?? device.host} — ${device.host}:${device.port}`;
+}
+
 function readStdin() {
   try {
     return readFileSync(0, 'utf8');
@@ -135,6 +161,14 @@ async function discoverViaMulticastJS() {
   });
 }
 
+async function askTTY(question) {
+  const { createInterface } = await import('node:readline/promises');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question(question);
+  rl.close();
+  return answer.trim();
+}
+
 /** Let the user pick between several discovered phones. */
 async function chooseDevice(devices) {
   console.log('Multiple CarMoji devices found:');
@@ -143,10 +177,7 @@ async function chooseDevice(devices) {
     console.error('\nRe-run with the address of the one you want: carmoji pair <code> <ip[:port]>');
     process.exit(1);
   }
-  const { createInterface } = await import('node:readline/promises');
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await rl.question(`Pair with which one? [1-${devices.length}] `);
-  rl.close();
+  const answer = await askTTY(`Pair with which one? [1-${devices.length}] `);
   const device = devices[Number(answer) - 1];
   if (!device) {
     console.error('Invalid choice.');
@@ -220,6 +251,30 @@ async function requestApproval(config, message, timeoutMs = 55_000) {
   });
 }
 
+/** Fan one event out to every paired phone in parallel; one slow or
+ *  unreachable device can't delay the others past SEND_TIMEOUT_MS. */
+function sendAll(devices, message) {
+  return Promise.all(devices.map((device) => send(device, message)));
+}
+
+/**
+ * Show the approval card on every paired phone; the first tap anywhere
+ * wins. The other phones' cards drop when this process exits and their
+ * sockets close. Resolves null when nobody answers in time.
+ */
+function requestApprovalAll(devices, message, timeoutMs) {
+  if (devices.length === 0) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    let pending = devices.length;
+    for (const device of devices) {
+      requestApproval(device, message, timeoutMs).then((decision) => {
+        pending -= 1;
+        if (decision || pending === 0) resolve(decision);
+      });
+    }
+  });
+}
+
 function summarizeToolInput(payload) {
   const input = payload.tool_input || {};
   const text = input.command || input.file_path || input.description
@@ -329,7 +384,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 +447,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 +460,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 +497,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 +513,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 +662,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 +765,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 } = {}) {
@@ -841,27 +1001,92 @@ async function main() {
         }
         target = devices.length === 1 ? devices[0] : await chooseDevice(devices);
       }
-      const config = { host: target.host, port: target.port, code: arg };
-      const result = await send(config, { source: 'bridge', event: 'turn_done' });
+      const device = { name: target.name, host: target.host,
+                       port: target.port, code: arg };
+      const result = await send(device, { source: 'bridge', event: 'turn_done' });
       if (result !== 'ok') {
         console.error(result === 'bad-code'
           ? `"${target.name}" (${target.host}:${target.port}) rejected the pairing code — check that device’s Code Buddy sheet. (Wrong phone? Pass its address: carmoji pair <code> <ip[:port]>)`
           : `Found "${target.name}" at ${target.host}:${target.port} but couldn’t talk to it (${result}).`);
         process.exit(1);
       }
-      saveConfig(config);
+      // Pairing the same device again just refreshes its code; other
+      // devices stay paired unless the user says otherwise here.
+      const others = loadDevices().filter(
+        (d) => !(d.host === device.host && Number(d.port) === Number(device.port)));
+      let kept = others;
+      if (others.length > 0) {
+        console.log('Already paired with:');
+        others.forEach((d) => console.log(`  ${deviceLabel(d)}`));
+        if (process.stdin.isTTY) {
+          const answer = await askTTY(
+            'Keep them too? Events go to every paired device. [Y/n] ');
+          if (/^n/i.test(answer)) {
+            kept = [];
+            console.log('Unpaired them — events go only to the new device.');
+          }
+        } else {
+          console.log('Keeping them — events fan out to every paired device.'
+            + ' (`carmoji unpair` removes one.)');
+        }
+      }
+      saveDevices([...kept, device]);
       console.log(`Paired with "${target.name}" at ${target.host}:${target.port} — the pet should be celebrating!`);
       break;
     }
 
+    case 'unpair': {
+      const devices = loadDevices();
+      if (devices.length === 0) {
+        console.log('Not paired with any device.');
+        break;
+      }
+      let goners;
+      if (arg === 'all') {
+        goners = devices;
+      } else if (arg) {
+        goners = devices.filter((d) => d.name === arg || d.host === arg
+          || `${d.host}:${d.port}` === arg);
+        if (goners.length === 0) {
+          console.error(`No paired device matches "${arg}". Paired:`);
+          devices.forEach((d) => console.error(`  ${deviceLabel(d)}`));
+          process.exit(1);
+        }
+      } else if (devices.length === 1) {
+        goners = devices;
+      } else if (process.stdin.isTTY) {
+        console.log('Paired devices:');
+        devices.forEach((d, i) => console.log(`  ${i + 1}. ${deviceLabel(d)}`));
+        const answer = await askTTY(
+          `Unpair which one? [1-${devices.length}, or "all"] `);
+        if (answer.toLowerCase() === 'all') {
+          goners = devices;
+        } else {
+          const device = devices[Number(answer) - 1];
+          if (!device) {
+            console.error('Invalid choice.');
+            process.exit(1);
+          }
+          goners = [device];
+        }
+      } else {
+        console.error('Several devices are paired — name one: carmoji unpair <name|ip[:port]|all>');
+        devices.forEach((d) => console.error(`  ${deviceLabel(d)}`));
+        process.exit(1);
+      }
+      saveDevices(devices.filter((d) => !goners.includes(d)));
+      goners.forEach((d) => console.log(`Unpaired ${deviceLabel(d)}.`));
+      break;
+    }
+
     case 'hook': {
       // 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 devices = loadDevices();
+        if (devices.length === 0) break;
         const flags = [arg, ...rest].filter(Boolean);
         const flagValue = (name) => {
           const index = flags.indexOf(name);
@@ -875,7 +1100,7 @@ async function main() {
         // the phone shows Allow/Deny; the printed JSON settles the
         // permission. Timeout falls through to the normal terminal prompt.
         if (flags.includes('--gate') && payload.hook_event_name === 'PreToolUse') {
-          const decision = await requestApproval(config, {
+          const decision = await requestApprovalAll(devices, {
             source,
             session: payload.session_id,
             event: 'approval_request',
@@ -903,8 +1128,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 +1141,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;
@@ -926,7 +1152,7 @@ async function main() {
           const usage = claudeUsage(recompute);
           if (usage) message.usage = usage;
         }
-        await send(config, message);
+        await sendAll(devices, message);
       } catch {
         // Never surface errors into the coding session.
       }
@@ -935,14 +1161,14 @@ async function main() {
 
     case 'codex-notify': {
       try {
-        const config = loadConfig();
-        if (!config) break;
+        const devices = loadDevices();
+        if (devices.length === 0) break;
         const payload = JSON.parse(process.argv[process.argv.length - 1] || '{}');
         if (payload.type === 'agent-turn-complete') {
           const session = payload['conversation-id'] || payload.conversation_id;
           const message = { source: 'codex', session, event: 'turn_done' };
           if (payload.cwd) message.project = basename(payload.cwd);
-          await send(config, message);
+          await sendAll(devices, message);
         }
       } catch {
         // Same rule as `hook`: stay silent.
@@ -956,8 +1182,8 @@ async function main() {
         console.error(`Usage: carmoji test <${Object.keys(TEST_EVENTS).join('|')}> [session] [tokens]`);
         process.exit(1);
       }
-      const config = loadConfig();
-      if (!config) {
+      const devices = loadDevices();
+      if (devices.length === 0) {
         console.error('Not paired yet — run: carmoji pair <code>');
         process.exit(1);
       }
@@ -967,9 +1193,12 @@ async function main() {
       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);
+      const results = await sendAll(devices, message);
+      results.forEach((result, index) => {
+        console.log(`  ${deviceLabel(devices[index])}: ${
+          result === 'ok' ? 'sent!' : `failed (${result})`}`);
+      });
+      process.exit(results.every((result) => result === 'ok') ? 0 : 1);
       break;
     }
 
@@ -1061,8 +1290,26 @@ async function main() {
       break;
 
     default:
-      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');
+      console.log('carmoji bridge — usage: pair <code> [ip[:port]] | unpair [<name|ip[:port]>|all] | discover | install <tool>|all | uninstall <tool> | tools | test <event> | hook [--source <tool>] [--event <name>] [--gate] | codex-notify | claude-config | codex-config | gate-config');
+  }
+}
+
+export {
+  applyTranscriptTokenRecord,
+  eventFromHook,
+  normalizeDevices,
+  stripLegacyCarMojiNotifyLine,
+};
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(SCRIPT_PATH);
+  } catch {
+    return false;
   }
 }
 
-main().then(() => process.exit(process.exitCode ?? 0));
+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.3",
   "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"