carmoji 0.3.6 → 0.3.8

package/README.md

@@ -153,10 +153,11 @@ 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)
+## Answer permissions from the phone (Claude Code and Codex)
 
-`carmoji install claude` hooks Claude Code's `PermissionRequest` event,
-which fires **only when a permission dialog is about to appear** —
+`carmoji install claude` and `carmoji install codex` hook each agent's
+`PermissionRequest` event, which fires **only when a permission dialog is
+about to appear** —
 allowlisted tools and auto-accepted edits never trigger it, so nothing
 ever slows down a call that would have run anyway. When it fires, the
 phone chimes (a doorbell sound used by nothing else), shows big pleading
@@ -165,14 +166,14 @@ settles the prompt on the computer via the hook's official decision
 output. No answer within ~55 s falls through to the normal terminal
 prompt (`npx carmoji test approval` exercises the whole loop).
 
-Simple **AskUserQuestion** pickers ride the same hook: one single-select
-question with 2–4 labeled options becomes a tappable option card on the
-phone (`npx carmoji test question` demos it), and your pick is fed back
-as the answer. Richer questions — several at once, multi-select, free
-text — still show as a pleading toast and are answered in the terminal.
-
-Honest limits: the Codex integration currently treats `PermissionRequest`
-as display-only (answering from the phone is planned next).
+For Claude Code, simple **AskUserQuestion** pickers ride the same hook: one
+single-select question with 2–4 labeled options becomes a tappable option
+card on the phone (`npx carmoji test question` demos it), and your pick is
+fed back as the answer. Richer questions — several at once, multi-select,
+free text — still show as a pleading toast and are answered in the terminal.
+Codex questions use its App Server `requestUserInput` protocol rather than
+lifecycle hooks, so they remain terminal-only; Codex Allow/Deny permission
+approvals do work from the phone.
 
 Older Claude Code versions without the `PermissionRequest` hook can use
 `npx carmoji config gate` instead: a legacy `PreToolUse` gate with a tool

package/carmoji.js

@@ -245,6 +245,7 @@ async function requestApproval(config, message, timeoutMs = 55_000, requireCap)
         const reply = JSON.parse(data.toString());
         if (reply.ok === false) return finish(null);
         if (reply.decision === 'allow' || reply.decision === 'deny'
+            || reply.decision === 'always'
             || typeof reply.answer === 'string') {
           return finish(reply);
         }
@@ -487,10 +488,41 @@ function normalizePayload(payload, eventFlag) {
   return payload;
 }
 
+/** Tools that carry the agent's own task list in their input. */
+const TODO_TOOLS = new Set(['TodoWrite', 'update_plan']);
+
+/**
+ * The agent's task list, normalized from Claude's TodoWrite
+ * (`todos: [{content, status, activeForm}]`) or Codex's update_plan
+ * (`plan: [{step, status}]`). Every call carries the whole list, so the
+ * phone can render progress and diff for freshly completed items.
+ */
+function todosFromInput(input) {
+  const raw = Array.isArray(input?.todos) ? input.todos
+    : Array.isArray(input?.plan) ? input.plan : undefined;
+  if (!raw) return undefined;
+  const normalize = (status) =>
+    ['completed', 'complete', 'done'].includes(status) ? 'done'
+      : ['in_progress', 'active'].includes(status) ? 'active' : 'pending';
+  const items = raw.slice(0, 12).map((item) => ({
+    text: String(item.content ?? item.step ?? item.text ?? '')
+      .replace(/\s+/g, ' ').trim().slice(0, 80),
+    status: normalize(item.status),
+  })).filter((item) => item.text);
+  return items.length ? items : undefined;
+}
+
 /** 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];
+  // The task list rides its own event: updating it is bookkeeping, not
+  // "running a command", so it must not pull the nervous tool face.
+  // Pre and Post both carry the list; sending twice is a no-op diff.
+  if (TODO_TOOLS.has(tool)) {
+    const todos = todosFromInput(payload.tool_input);
+    if (todos) return { event: 'todos', todos };
+  }
   switch (EVENT_ALIASES[raw] ?? raw) {
     case 'SessionStart': return { event: 'session_start' };
     case 'UserPromptSubmit': return { event: 'prompt' };
@@ -613,10 +645,20 @@ const APPROVAL_WAIT_MS = 55_000;
 const HOLD_WAIT_MS = 120_000;
 const PERMISSION_HOOK_TIMEOUT_S = 150;
 
-/** Sources whose PermissionRequest hook accepts a decision back via
- *  `hookSpecificOutput.decision` (Claude Code's schema). Codex is the next
- *  candidate once its hooks are verified to honor the reply. */
-const ANSWERABLE_PERMISSION_SOURCES = new Set(['claude']);
+/** Sources whose PermissionRequest hook accepts Allow/Deny through
+ *  `hookSpecificOutput.decision`. */
+const ANSWERABLE_APPROVAL_SOURCES = new Set(['claude', 'codex']);
+
+/** Sources whose decision also honors `updatedPermissions` — lets the phone
+ *  offer "Always allow" (a session-scoped rule, mirroring the terminal
+ *  dialog's don't-ask-again row). Codex hooks ignore updatedPermissions, so
+ *  its card stays Allow/Deny. */
+const ALWAYS_ALLOW_SOURCES = new Set(['claude']);
+
+/** Sources whose question protocol accepts `decision.updatedInput`.
+ *  Codex questions use App Server requestUserInput instead of hooks, so a
+ *  synthetic AskUserQuestion event must remain display-only. */
+const ANSWERABLE_QUESTION_SOURCES = new Set(['claude']);
 
 // ---------------------------------------------------------------------------
 // Multi-tool hook installers (see EVENT_ALIASES for how their events map).
@@ -1245,8 +1287,7 @@ async function main() {
         // to the terminal dialog.
         const canonicalEvent = EVENT_ALIASES[payload.hook_event_name]
           ?? payload.hook_event_name;
-        if (canonicalEvent === 'PermissionRequest'
-            && ANSWERABLE_PERMISSION_SOURCES.has(source)) {
+        if (canonicalEvent === 'PermissionRequest') {
           const common = {
             source,
             session: payload.session_id,
@@ -1260,7 +1301,8 @@ async function main() {
           // looks answers up by it — keying by header yields empty answers)
           // with the original `questions` kept in place (Claude Code crashes
           // on its absence). Richer shapes fall through to display-only.
-          if (payload.tool_name === 'AskUserQuestion') {
+          if (payload.tool_name === 'AskUserQuestion'
+              && ANSWERABLE_QUESTION_SOURCES.has(source)) {
             const question = answerableQuestion(payload.tool_input);
             if (question) {
               const reply = await requestApprovalAll(devices, {
@@ -1292,18 +1334,36 @@ async function main() {
             }
             // No card, no tap, or an unknown label: fall through to the
             // pleading face + toast; the picker stays in the terminal.
-          } else {
+          } else if (payload.tool_name !== 'AskUserQuestion'
+                     && ANSWERABLE_APPROVAL_SOURCES.has(source)) {
+            const canAlways = ALWAYS_ALLOW_SOURCES.has(source)
+              && Boolean(payload.tool_name);
             const decision = (await requestApprovalAll(devices, {
               ...common,
               event: 'approval_request',
               tool: payload.tool_name,
               detail: summarizeToolInput(payload),
+              // Tells the phone it may offer an "Always allow" button;
+              // older app builds don't know the field and show Allow/Deny.
+              ...(canAlways ? { always: true } : {}),
             }, APPROVAL_WAIT_MS))?.decision;
             if (decision) {
+              const settled = { behavior: decision === 'always' ? 'allow' : decision };
+              if (decision === 'always' && canAlways) {
+                // Session-scoped don't-ask-again rule. A bare toolName rule
+                // allows every use of the tool; MCP tools (mcp__server__tool)
+                // in particular reject a ruleContent specifier.
+                settled.updatedPermissions = [{
+                  type: 'addRules',
+                  rules: [{ toolName: payload.tool_name }],
+                  behavior: 'allow',
+                  destination: 'session',
+                }];
+              }
               console.log(JSON.stringify({
                 hookSpecificOutput: {
                   hookEventName: 'PermissionRequest',
-                  decision: { behavior: decision },
+                  decision: settled,
                 },
               }));
             }
@@ -1367,8 +1427,8 @@ async function main() {
 
     case 'test': {
       const event = TEST_EVENTS[arg];
-      if (!event && arg !== 'approval' && arg !== 'question') {
-        console.error(`Usage: carmoji test <${Object.keys(TEST_EVENTS).join('|')}|approval|question> [session] [tokens] [project] — details: carmoji test --help`);
+      if (!event && !['approval', 'question', 'todos'].includes(arg)) {
+        console.error(`Usage: carmoji test <${Object.keys(TEST_EVENTS).join('|')}|approval|question|todos> [session] [tokens] [project] — details: carmoji test --help`);
         process.exit(1);
       }
       const devices = loadDevices();
@@ -1386,10 +1446,11 @@ async function main() {
           event: 'approval_request',
           tool: 'Bash',
           detail: 'carmoji test approval — tap Allow or Deny',
+          always: true,
         }, APPROVAL_WAIT_MS))?.decision;
         console.log(decision
           ? `Decision: ${decision}`
-          : 'No answer — in a real session Claude Code would fall through to the terminal prompt.');
+          : 'No answer — in a real session the coding agent would fall through to the terminal prompt.');
         process.exit(decision ? 0 : 1);
       }
       if (arg === 'question') {
@@ -1417,6 +1478,28 @@ async function main() {
           : 'No answer — in a real session the picker would stay in the terminal.');
         process.exit(answer ? 0 : 1);
       }
+      if (arg === 'todos') {
+        // Seeds a five-step demo list; raise `done` call by call to walk a
+        // task across the board and fire the completed-item flourish:
+        //   carmoji test todos [session] [done 0-5]
+        const [session, doneArg] = rest;
+        const done = Math.max(0, Math.min(5, Number(doneArg ?? 1) || 0));
+        const steps = ['Explore the codebase', 'Write the failing test',
+                       'Implement the fix', 'Run the test suite',
+                       'Update the docs'];
+        const todos = steps.map((text, index) => ({
+          text,
+          status: index < done ? 'done' : index === done ? 'active' : 'pending',
+        }));
+        const message = { source: 'test', session, host: hostname(),
+                          event: 'todos', todos };
+        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);
+      }
       const [session, tokens, project] = rest;
       const message = { source: 'test', session, host: hostname(), ...event };
       if (tokens !== undefined) message.tokens = Number(tokens);
@@ -1599,16 +1682,16 @@ tool's dialect (beforeShellExecution, TaskComplete, permission_request, …);
 see EVENT_ALIASES in carmoji.js for the full mapping. Unknown events are
 silently ignored.
 
-Blocking: a Claude Code PermissionRequest holds the hook open up to ${APPROVAL_WAIT_MS / 1000}s
+Blocking: a Claude Code or Codex PermissionRequest holds the hook open up to ${APPROVAL_WAIT_MS / 1000}s
 while the phone shows a card, then prints the decision for the agent:
   {"hookSpecificOutput":{"hookEventName":"PermissionRequest",
                          "decision":{"behavior":"allow"}}}
-AskUserQuestion gets an option-picker card instead when it's one
-single-select question with 2–4 labeled options; the tapped label — or
-free text typed behind the card's "Other…" button, which sends
+For Claude Code, AskUserQuestion gets an option-picker card instead when
+it's one single-select question with 2–4 labeled options; the tapped label
+— or free text typed behind the card's "Other…" button, which sends
 {hold:true} to stretch the wait to ${HOLD_WAIT_MS / 1000}s — comes back via
 decision.updatedInput.answers. Multi-question and multiSelect stay
-display-only.
+display-only; Codex questions use App Server requestUserInput instead.
 No tap → no output → the normal terminal prompt appears.
 
 Try it:

package/package.json

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