claude-remote-approver 0.3.7 → 0.5.0

package/README.md

@@ -51,7 +51,7 @@ npm install -g claude-remote-approver
 claude-remote-approver setup
 ```
 
-Setup prints a QR code. Scan it with the ntfy app to subscribe, and you are done.
+Setup prints a QR code. Scan it with the ntfy app to subscribe, then **start a new Claude Code session**. The hook is loaded at session startup, so any session that was already running before installation will not have the hook active.
 
 ## Installation
 
@@ -169,6 +169,7 @@ Config file location: `~/.claude-remote-approver.json`
   "topic": "cra-a1b2c3d4e5f67890abcdef1234567890",
   "ntfyServer": "https://ntfy.sh",
   "timeout": 120,
+  "planTimeout": 300,
   "autoApprove": [],
   "autoDeny": []
 }
@@ -179,6 +180,7 @@ Config file location: `~/.claude-remote-approver.json`
 | `topic` | `string` | `""` | Your unique ntfy topic. Generated by `setup`. |
 | `ntfyServer` | `string` | `"https://ntfy.sh"` | The ntfy server URL. Change this if you self-host. |
 | `timeout` | `number` | `120` | Seconds to wait for a response before auto-denying. |
+| `planTimeout` | `number` | `300` | Seconds to wait for ExitPlanMode (plan approval) responses. Plan reviews need more reading time. |
 | `autoApprove` | `string[]` | `[]` | Reserved for future use. |
 | `autoDeny` | `string[]` | `[]` | Reserved for future use. |
 

package/bin/cli.mjs

@@ -87,8 +87,8 @@ export async function main(args, deps) {
       try {
         input = JSON.parse(deps.stdin);
       } catch {
-        const deny = { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
-        deps.stdout.write(JSON.stringify(deny) + "\n");
+        const ask = { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "ask" } } };
+        deps.stdout.write(JSON.stringify(ask) + "\n");
         break;
       }
 
@@ -96,8 +96,8 @@ export async function main(args, deps) {
       try {
         result = await deps.processHook(input, deps);
       } catch {
-        const deny = { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
-        deps.stdout.write(JSON.stringify(deny) + "\n");
+        const ask = { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "ask" } } };
+        deps.stdout.write(JSON.stringify(ask) + "\n");
         break;
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-approver",
-  "version": "0.3.7",
+  "version": "0.5.0",
   "description": "Approve or deny Claude Code permission prompts remotely from your phone via ntfy.sh",
   "type": "module",
   "bin": {

package/src/config.mjs

@@ -9,6 +9,7 @@ export const DEFAULT_CONFIG = {
   topic: "",
   ntfyServer: "https://ntfy.sh",
   timeout: 120,
+  planTimeout: 300,
   // autoApprove/autoDeny are reserved for future use and not yet implemented
   autoApprove: [],
   autoDeny: [],
@@ -21,7 +22,8 @@ export function loadConfig(configPath = CONFIG_PATH) {
     const config = { ...DEFAULT_CONFIG, ...fileConfig };
     if (typeof config.topic !== "string") config.topic = DEFAULT_CONFIG.topic;
     if (typeof config.ntfyServer !== "string") config.ntfyServer = DEFAULT_CONFIG.ntfyServer;
-    if (typeof config.timeout !== "number" || config.timeout <= 0) config.timeout = DEFAULT_CONFIG.timeout;
+    if (!Number.isFinite(config.timeout) || config.timeout <= 0) config.timeout = DEFAULT_CONFIG.timeout;
+    if (!Number.isFinite(config.planTimeout) || config.planTimeout <= 0) config.planTimeout = DEFAULT_CONFIG.planTimeout;
     if (!Array.isArray(config.autoApprove)) config.autoApprove = DEFAULT_CONFIG.autoApprove;
     if (!Array.isArray(config.autoDeny)) config.autoDeny = DEFAULT_CONFIG.autoDeny;
     return config;

package/src/hook.mjs

@@ -1,6 +1,11 @@
 // src/hook.mjs
 
 import crypto from "node:crypto";
+import { DEFAULT_CONFIG } from "./config.mjs";
+
+const ASK = Object.freeze({ hookSpecificOutput: Object.freeze({ hookEventName: "PermissionRequest", decision: Object.freeze({ behavior: "ask" }) }) });
+const DENY = Object.freeze({ hookSpecificOutput: Object.freeze({ hookEventName: "PermissionRequest", decision: Object.freeze({ behavior: "deny" }) }) });
+const MAX_RETRIES = 3;
 
 /**
  * Build ntfy action buttons for Approve / Deny.
@@ -30,6 +35,135 @@ export function buildActions(server, topic, requestId) {
   ];
 }
 
+/**
+ * Send with retry, returning null on exhausted retries.
+ */
+export async function sendWithRetry(sendFn, params) {
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    try {
+      return await sendFn(params);
+    } catch (err) {
+      if (i === MAX_RETRIES - 1) {
+        console.error("sendNotification failed:", err);
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if the input is an AskUserQuestion tool call with questions.
+ */
+export function isAskUserQuestion(input) {
+  return (
+    input?.tool_name === "AskUserQuestion" &&
+    Array.isArray(input?.tool_input?.questions) &&
+    input.tool_input.questions.length > 0
+  );
+}
+
+/**
+ * Build ntfy action buttons for question options.
+ */
+export function buildQuestionActions(server, topic, requestId, options) {
+  const url = `${server}/${topic}-response`;
+  return options.map((opt) => ({
+    action: "http",
+    label: opt.label,
+    url,
+    body: JSON.stringify({ requestId, answer: opt.label }),
+    method: "POST",
+  }));
+}
+
+/**
+ * Build a human-readable message for a question with options.
+ */
+export function buildQuestionMessage(question, options, opts = {}) {
+  const { multiSelect, batchInfo } = opts;
+  let msg = question;
+  if (batchInfo) msg += ` ${batchInfo}`;
+  if (multiSelect) msg += "\n(multiple selections allowed)";
+  msg += "\n\n";
+  for (const opt of options) {
+    msg += `• ${opt.label}: ${opt.description}\n`;
+  }
+  return msg.trimEnd();
+}
+
+/**
+ * Process an AskUserQuestion hook request.
+ */
+export async function processAskUserQuestion(input, deps) {
+  const config = deps.loadConfig();
+  if (!config.topic) return ASK;
+
+  const questions = input.tool_input.questions;
+  const answers = {};
+
+  for (const q of questions) {
+    const requestId = crypto.randomUUID();
+    const options = q.options;
+
+    const MAX_BUTTONS = 3;
+    const batches = [];
+    for (let j = 0; j < options.length; j += MAX_BUTTONS) {
+      batches.push(options.slice(j, j + MAX_BUTTONS));
+    }
+
+    for (let i = 0; i < batches.length; i++) {
+      const batch = batches[i];
+      const batchInfo = batches.length > 1 ? `(${i + 1}/${batches.length})` : undefined;
+      const actions = buildQuestionActions(config.ntfyServer, config.topic, requestId, batch);
+      const message = buildQuestionMessage(q.question, batch, { multiSelect: q.multiSelect, batchInfo });
+
+      const sent = await sendWithRetry(deps.sendNotification, {
+        server: config.ntfyServer,
+        topic: config.topic,
+        title: `Claude Code: ${q.header || "Question"}`,
+        message,
+        actions,
+        requestId,
+      });
+      if (!sent) return ASK;
+    }
+
+    // AskUserQuestion uses standard timeout (not planTimeout)
+    let response;
+    try {
+      response = await deps.waitForResponse({
+        server: config.ntfyServer,
+        topic: config.topic,
+        requestId,
+        timeout: config.timeout * 1000,
+      });
+    } catch (err) {
+      console.error("waitForResponse failed:", err);
+      return ASK;
+    }
+
+    if (response.answer) {
+      answers[q.question] = response.answer;
+    } else {
+      return ASK;
+    }
+  }
+
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: {
+        behavior: "allow",
+        updatedInput: {
+          questions: input.tool_input.questions,
+          answers,
+        },
+      },
+    },
+  };
+}
+
 /**
  * Process a Claude Code hook request.
  *
@@ -45,38 +179,43 @@ export async function processHook(input, { loadConfig, sendNotification, waitFor
   const config = loadConfig();
 
   if (!config.topic) {
-    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
+    return ASK;
+  }
+
+  if (isAskUserQuestion(input)) {
+    return processAskUserQuestion(input, { loadConfig, sendNotification, waitForResponse });
   }
 
   const requestId = crypto.randomUUID();
   const { title, message } = formatToolInfo(input);
   const actions = buildActions(config.ntfyServer, config.topic, requestId);
 
-  try {
-    await sendNotification({
-      server: config.ntfyServer,
-      topic: config.topic,
-      title,
-      message,
-      actions,
-      requestId,
-    });
-  } catch (err) {
-    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
-  }
+  const sent = await sendWithRetry(sendNotification, {
+    server: config.ntfyServer,
+    topic: config.topic,
+    title,
+    message,
+    actions,
+    requestId,
+  });
+  if (!sent) return ASK;
 
   let response;
   try {
+    const isPlanReview = input.tool_name === "ExitPlanMode";
+    const timeout = (isPlanReview ? (config.planTimeout ?? DEFAULT_CONFIG.planTimeout) : config.timeout) * 1000;
     response = await waitForResponse({
       server: config.ntfyServer,
       topic: config.topic,
       requestId,
-      timeout: config.timeout * 1000,
+      timeout,
     });
   } catch (err) {
-    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
+    console.error("waitForResponse failed:", err);
+    return ASK;
   }
 
-  const behavior = response.approved ? "allow" : "deny";
-  return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior } } };
+  if (response.timeout || response.error) return ASK;
+  if (response.approved === false) return DENY;
+  return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } };
 }

package/src/ntfy.mjs

@@ -27,7 +27,7 @@ export async function sendNotification({ server, topic, title, message, actions,
  * Subscribe to the response topic via SSE and wait for a matching requestId.
  *
  * @param {{ server: string, topic: string, requestId: string, timeout: number }} params
- * @returns {Promise<{ approved: boolean }>}
+ * @returns {Promise<{ approved: boolean } | { timeout: true } | { error: Error } | { answer: string }>}
  */
 export async function waitForResponse({ server, topic, requestId, timeout }) {
   const baseUrl = server.replace(/\/+$/, '');
@@ -70,6 +70,9 @@ export async function waitForResponse({ server, topic, requestId, timeout }) {
               clearTimeout(timer);
               controller.signal.removeEventListener('abort', onAbort);
               controller.abort();
+              if (typeof parsed.answer === 'string') {
+                return { answer: parsed.answer };
+              }
               return { approved: parsed.approved };
             }
           } catch {
@@ -82,16 +85,356 @@ export async function waitForResponse({ server, topic, requestId, timeout }) {
     }
 
     clearTimeout(timer);
-    return { approved: false };
+    return { timeout: true };
   } catch (err) {
     if (timer !== undefined) clearTimeout(timer);
-    if (err?.name !== "AbortError") {
-      console.error("[claude-remote-approver] waitForResponse error:", err);
+    if (err?.name === "AbortError") {
+      return { timeout: true };
     }
-    return { approved: false };
+    console.error("[claude-remote-approver] waitForResponse error:", err);
+    return { error: err };
   }
 }
 
+/**
+ * Strip markdown formatting from text, returning plain text.
+ *
+ * @param {string} text - Markdown text to strip
+ * @returns {string} Plain text with markdown removed
+ */
+export function stripMarkdown(text) {
+  // Input guard
+  if (text.length > MAX_INPUT) {
+    text = text.slice(0, MAX_INPUT);
+  }
+
+  // Order matters: fenced code blocks must be first to prevent processing markdown inside them.
+  let result = text
+    .replace(/```[\s\S]*?(?:```|$)/g, '')                // Fenced code blocks
+    .replace(/^[ \t]*(?:(?:-[ \t]*){3,}|(?:\*[ \t]*){3,}|(?:_[ \t]*){3,})$/gm, '') // Horizontal rules (before list markers)
+    .replace(/^#{1,6}\s+/gm, '')                          // Headers
+    .replace(/^(?:>[ \t]?)+/gm, '')                       // Block quotes
+    .replace(/^[ \t]*[-*+] /gm, '')                       // Unordered list markers with indent
+    .replace(/^[ \t]*\d+\. /gm, '');                      // Ordered list markers with indent
+
+  result = stripInline(result);
+
+  return result.replace(/\n{2,}/g, '\n').trim();
+}
+
+// ---------------------------------------------------------------------------
+// Constants and helpers
+// ---------------------------------------------------------------------------
+
+const MAX_INPUT = 10000;
+
+/**
+ * Count consecutive runs of character ch starting at pos.
+ *
+ * @param {string} text
+ * @param {number} pos
+ * @param {string} ch
+ * @returns {number}
+ */
+function countRun(text, pos, ch) {
+  let count = 0;
+  while (pos + count < text.length && text[pos + count] === ch) count++;
+  return count;
+}
+
+const RE_ALPHANUMERIC = /[a-zA-Z0-9]/;
+const RE_WHITESPACE = /\s/;
+const RE_ASCII_PUNCTUATION = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+
+/**
+ * @param {string} ch
+ * @returns {boolean}
+ */
+function isAlphanumeric(ch) { return RE_ALPHANUMERIC.test(ch); }
+
+/**
+ * @param {string} ch
+ * @returns {boolean}
+ */
+function isWhitespace(ch) { return RE_WHITESPACE.test(ch); }
+
+/**
+ * @param {string} ch
+ * @returns {boolean}
+ */
+function isAsciiPunctuation(ch) { return RE_ASCII_PUNCTUATION.test(ch); }
+
+/**
+ * Precompute matched bracket/paren pairs using a stack in O(n).
+ * Skips backslash-escaped characters so that \[ \] \( \) don't create false pairs.
+ * Returns a Map from opening index to closing index.
+ *
+ * @param {string} str
+ * @param {string} open
+ * @param {string} close
+ * @returns {Map<number, number>}
+ */
+function precomputePairs(str, open, close) {
+  const pairs = new Map();
+  const stack = [];
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] === '\\' && i + 1 < str.length && isAsciiPunctuation(str[i + 1])) {
+      i += 2;
+      continue;
+    }
+    // Skip code spans — brackets inside are literal
+    if (str[i] === '`') {
+      const tickCount = countRun(str, i, '`');
+      const closeIdx = findBacktickCloser(str, tickCount, i + tickCount);
+      if (closeIdx !== -1) {
+        i = closeIdx + tickCount;
+        continue;
+      }
+      i += tickCount;
+      continue;
+    }
+    if (str[i] === open) stack.push(i);
+    else if (str[i] === close && stack.length > 0) {
+      pairs.set(stack.pop(), i);
+    }
+    i++;
+  }
+  return pairs;
+}
+
+/**
+ * Find exactly tickCount consecutive backticks (not more, not less).
+ * CommonMark: backslash inside code spans is literal, so no escape skipping.
+ *
+ * @param {string} text
+ * @param {number} tickCount
+ * @param {number} start
+ * @returns {number}
+ */
+function findBacktickCloser(text, tickCount, start) {
+  let i = start;
+  while (i < text.length) {
+    if (text[i] === '`') {
+      const run = countRun(text, i, '`');
+      if (run === tickCount) return i;
+      i += run;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+
+/**
+ * Find a closing ~~ for strikethrough, skipping backslash-escaped characters.
+ *
+ * @param {string} text
+ * @param {number} start
+ * @returns {number}
+ */
+function findStrikethroughCloser(text, start) {
+  let i = start;
+  while (i < text.length - 1) {
+    if (text[i] === '\\' && isAsciiPunctuation(text[i + 1])) {
+      i += 2;
+      continue;
+    }
+    if (text[i] === '~' && text[i + 1] === '~') return i;
+    i++;
+  }
+  return -1;
+}
+
+/**
+ * Find a closer for emphasis marker ch with at least markerLen consecutive chars.
+ * Skips \* and \_ (escaped markers).
+ * Closer condition: run >= markerLen AND preceding char is not whitespace.
+ *
+ * @param {string} text
+ * @param {string} ch
+ * @param {number} markerLen
+ * @param {number} start
+ * @returns {number}
+ */
+function findEmphasisCloser(text, ch, markerLen, start) {
+  let i = start;
+  while (i < text.length) {
+    if (text[i] === '\\' && i + 1 < text.length && isAsciiPunctuation(text[i + 1])) {
+      i += 2;
+      continue;
+    }
+    if (text[i] === ch) {
+      const run = countRun(text, i, ch);
+      if (run >= markerLen && i > 0 && !isWhitespace(text[i - 1])) return i;
+      i += run;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+
+/**
+ * Handle emphasis markers (* or _).
+ * Returns { output, nextPos } on success, or null if the run should be treated as literal.
+ *
+ * @param {string} text
+ * @param {number} pos
+ * @returns {{ output: string, nextPos: number } | null}
+ */
+function handleEmphasis(text, pos) {
+  const ch = text[pos];
+
+  // Count run length
+  const runLen = countRun(text, pos, ch);
+
+  // Opener condition:
+  //   - prevChar is NOT alphanumeric (or start of string)
+  //   - char after the run is NOT whitespace and not end of string
+  const prevChar = pos > 0 ? text[pos - 1] : '';
+  const afterIdx = pos + runLen;
+  const afterChar = afterIdx < text.length ? text[afterIdx] : '';
+
+  const isOpener = !isAlphanumeric(prevChar) && afterChar !== '' && !isWhitespace(afterChar);
+
+  if (!isOpener) return null;
+
+  // Try matching closest, longest-first (min(runLen, 3) down to 1)
+  const maxMarker = Math.min(runLen, 3);
+  // NOTE: O(n²) worst case when many openers lack closers (k openers × O(n) scan).
+  // Bounded by MAX_INPUT=10000; measured ~163ms worst case. Acceptable for notification text.
+  for (let markerLen = maxMarker; markerLen >= 1; markerLen--) {
+    let searchFrom = pos + runLen;
+    while (true) {
+      const idx = findEmphasisCloser(text, ch, markerLen, searchFrom);
+      if (idx === -1) break; // no closer found for this markerLen
+      const content = text.slice(pos + markerLen, idx);
+      if (content.length === 0) {
+        // Empty emphasis — skip this closer and keep searching
+        searchFrom = idx + countRun(text, idx, ch);
+        continue;
+      }
+      return { output: stripInline(content), nextPos: idx + markerLen };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Strip inline markdown formatting by scanning character by character.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function stripInline(text) {
+  // NOTE: Recursive calls for emphasis/strikethrough/link content.
+  // Depth bounded by nesting level (shallow in real-world markdown).
+  const bracketPairs = precomputePairs(text, '[', ']');
+  const parenPairs = precomputePairs(text, '(', ')');
+
+  let out = '';
+  let i = 0;
+
+  while (i < text.length) {
+    const ch = text[i];
+
+    if (ch === '\\' && i + 1 < text.length && isAsciiPunctuation(text[i + 1])) {
+      out += text[i + 1];
+      i += 2;
+      continue;
+    }
+
+    if (ch === '`') {
+      const tickCount = countRun(text, i, '`');
+      const closeIdx = findBacktickCloser(text, tickCount, i + tickCount);
+      if (closeIdx !== -1) {
+        out += text.slice(i + tickCount, closeIdx);
+        i = closeIdx + tickCount;
+        continue;
+      }
+      // Unclosed backtick(s) — output as literal
+      out += text.slice(i, i + tickCount);
+      i += tickCount;
+      continue;
+    }
+
+    if (ch === '!' && i + 1 < text.length && text[i + 1] === '[') {
+      const closeBracket = bracketPairs.get(i + 1);
+      if (closeBracket !== undefined && closeBracket + 1 < text.length && text[closeBracket + 1] === '(') {
+        const closeParen = parenPairs.get(closeBracket + 1);
+        if (closeParen !== undefined) {
+          const altText = text.slice(i + 2, closeBracket);
+          out += stripInline(altText);
+          i = closeParen + 1;
+          continue;
+        }
+      }
+      // Not a valid image — output ! as literal
+      out += ch;
+      i++;
+      continue;
+    }
+
+    if (ch === '[') {
+      const closeBracket = bracketPairs.get(i);
+      if (closeBracket !== undefined && closeBracket + 1 < text.length && text[closeBracket + 1] === '(') {
+        const closeParen = parenPairs.get(closeBracket + 1);
+        if (closeParen !== undefined) {
+          const linkText = text.slice(i + 1, closeBracket);
+          out += stripInline(linkText);
+          i = closeParen + 1;
+          continue;
+        }
+      }
+      // Not a valid link — output as literal
+      out += ch;
+      i++;
+      continue;
+    }
+
+    if (ch === '~' && i + 1 < text.length && text[i + 1] === '~') {
+      const searchStart = i + 2;
+      const closeIdx = findStrikethroughCloser(text, searchStart);
+      if (closeIdx !== -1) {
+        const content = text.slice(searchStart, closeIdx);
+        if (content.length === 0) {
+          out += '~~';
+          i += 2;
+          continue;
+        }
+        out += stripInline(content);
+        i = closeIdx + 2;
+        continue;
+      }
+      // No closer — output ~~ as literal
+      out += '~~';
+      i += 2;
+      continue;
+    }
+
+    if (ch === '*' || ch === '_') {
+      const result = handleEmphasis(text, i);
+      if (result !== null) {
+        out += result.output;
+        i = result.nextPos;
+        continue;
+      }
+      // Not an opener or no closer — output entire run as literal
+      const runLen = countRun(text, i, ch);
+      out += text.slice(i, i + runLen);
+      i += runLen;
+      continue;
+    }
+
+    out += ch;
+    i++;
+  }
+
+  return out;
+}
+
 /**
  * Format tool information for display in the notification.
  *
@@ -99,6 +442,21 @@ export async function waitForResponse({ server, topic, requestId, timeout }) {
  * @returns {{ title: string, message: string }}
  */
 export function formatToolInfo({ hook_event_name, tool_name, tool_input }) {
+  // Plan approval detection
+  if (tool_name === 'ExitPlanMode' && typeof tool_input?.plan === 'string') {
+    const PLAN_MESSAGE_MAX_LENGTH = 300;
+    const title = 'Claude Code: Plan Review';
+    if (!tool_input.plan.trim()) {
+      return { title, message: '(empty plan)' };
+    }
+    const raw = tool_input.plan;
+    const plain = stripMarkdown(raw);
+    const message = plain
+      ? (plain.length > PLAN_MESSAGE_MAX_LENGTH ? plain.slice(0, PLAN_MESSAGE_MAX_LENGTH) + '...' : plain)
+      : '(empty plan)';
+    return { title, message };
+  }
+
   const title = `Claude Code: ${tool_name}`;
   let message;