claude-remote-approver 0.3.5 → 0.3.7

package/bin/cli.mjs

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

package/package.json

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

package/src/hook.mjs

@@ -45,7 +45,7 @@ export async function processHook(input, { loadConfig, sendNotification, waitFor
   const config = loadConfig();
 
   if (!config.topic) {
-    return { hookSpecificOutput: { decision: { behavior: "deny" } } };
+    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
   }
 
   const requestId = crypto.randomUUID();
@@ -61,8 +61,8 @@ export async function processHook(input, { loadConfig, sendNotification, waitFor
       actions,
       requestId,
     });
-  } catch {
-    return { hookSpecificOutput: { decision: { behavior: "deny" } } };
+  } catch (err) {
+    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
   }
 
   let response;
@@ -73,10 +73,10 @@ export async function processHook(input, { loadConfig, sendNotification, waitFor
       requestId,
       timeout: config.timeout * 1000,
     });
-  } catch {
-    return { hookSpecificOutput: { decision: { behavior: "deny" } } };
+  } catch (err) {
+    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny" } } };
   }
 
   const behavior = response.approved ? "allow" : "deny";
-  return { hookSpecificOutput: { decision: { behavior } } };
+  return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior } } };
 }

package/src/ntfy.mjs

@@ -24,44 +24,72 @@ export async function sendNotification({ server, topic, title, message, actions,
 }
 
 /**
- * Poll the response topic and wait for a matching requestId.
+ * Subscribe to the response topic via SSE and wait for a matching requestId.
  *
- * @param {{ server: string, topic: string, requestId: string, timeout: number, pollInterval?: number }} params
+ * @param {{ server: string, topic: string, requestId: string, timeout: number }} params
  * @returns {Promise<{ approved: boolean }>}
  */
-export async function waitForResponse({ server, topic, requestId, timeout, pollInterval = 2000 }) {
+export async function waitForResponse({ server, topic, requestId, timeout }) {
   const baseUrl = server.replace(/\/+$/, '');
-  const sinceTimestamp = Math.floor(Date.now() / 1000);
-  const pollUrl = `${baseUrl}/${topic}-response/json?poll=1&since=${sinceTimestamp}`;
-  const startTime = Date.now();
+  const url = `${baseUrl}/${topic}-response/json`;
+
+  const controller = new AbortController();
+
+  /** @type {ReturnType<typeof setTimeout> | undefined} */
+  let timer;
+
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    // Listen to abort so we can cancel the reader even when the mock stream
+    // never closes (the real fetch would propagate the signal, but mocks may not).
+    const onAbort = () => reader.cancel();
+    controller.signal.addEventListener('abort', onAbort);
+
+    // Start the timeout AFTER fetch resolves so we measure waiting time only.
+    timer = setTimeout(() => controller.abort(), timeout);
 
-  while (Date.now() - startTime < timeout) {
     try {
-      const response = await fetch(pollUrl);
-      if (!response.ok) continue;
-      const text = await response.text();
-      const lines = text.trim().split('\n');
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const event = JSON.parse(line);
-          const parsed = JSON.parse(event.message);
-          if (parsed.requestId === requestId) {
-            return { approved: parsed.approved === true };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            const parsed = JSON.parse(event.message);
+            if (parsed.requestId === requestId) {
+              clearTimeout(timer);
+              controller.signal.removeEventListener('abort', onAbort);
+              controller.abort();
+              return { approved: parsed.approved };
+            }
+          } catch {
+            // skip non-JSON lines
           }
-        } catch {
-          // skip non-JSON lines
         }
       }
-    } catch (err) {
-      console.error("[claude-remote-approver] poll error:", err);
+    } finally {
+      controller.signal.removeEventListener('abort', onAbort);
     }
 
-    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    clearTimeout(timer);
+    return { approved: false };
+  } catch (err) {
+    if (timer !== undefined) clearTimeout(timer);
+    if (err?.name !== "AbortError") {
+      console.error("[claude-remote-approver] waitForResponse error:", err);
+    }
+    return { approved: false };
   }
-
-  return { approved: false };
 }
 
 /**