claude-remote-approver 0.3.4 → 0.3.5

package/package.json

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

package/src/ntfy.mjs

@@ -24,71 +24,44 @@ export async function sendNotification({ server, topic, title, message, actions,
 }
 
 /**
- * Subscribe to the response topic via SSE and wait for a matching requestId.
+ * Poll the response topic and wait for a matching requestId.
  *
- * @param {{ server: string, topic: string, requestId: string, timeout: number }} params
+ * @param {{ server: string, topic: string, requestId: string, timeout: number, pollInterval?: number }} params
  * @returns {Promise<{ approved: boolean }>}
  */
-export async function waitForResponse({ server, topic, requestId, timeout }) {
+export async function waitForResponse({ server, topic, requestId, timeout, pollInterval = 2000 }) {
   const baseUrl = server.replace(/\/+$/, '');
-  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);
+  const sinceTimestamp = Math.floor(Date.now() / 1000);
+  const pollUrl = `${baseUrl}/${topic}-response/json?poll=1&since=${sinceTimestamp}`;
+  const startTime = Date.now();
 
+  while (Date.now() - startTime < timeout) {
     try {
-      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);
-              return { approved: parsed.approved };
-            }
-          } catch {
-            // skip non-JSON lines
+      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 };
           }
+        } catch {
+          // skip non-JSON lines
         }
       }
-    } finally {
-      controller.signal.removeEventListener('abort', onAbort);
+    } catch (err) {
+      console.error("[claude-remote-approver] poll error:", err);
     }
 
-    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 };
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
   }
+
+  return { approved: false };
 }
 
 /**