patchcord 0.5.59 → 0.5.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.59",
+  "version": "0.5.61",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "author": "ppravdin",
   "license": "MIT",

package/scripts/subscribe.mjs

@@ -22,6 +22,11 @@ const RECONNECT_BACKOFF_MS = [1000, 2000, 4000, 8000, 15_000, 30_000];
 // gap means three missed heartbeats. Force a reconnect via the outer loop.
 const FRESHNESS_CHECK_INTERVAL_MS = 30_000;
 const FRESHNESS_STALE_MS = 90_000;
+// Re-emit pending count every minute as a safety net. The Realtime push
+// + Monitor pipeline can drop notifications when an agent is mid-tool-call
+// (especially for long-running work like vector-DB searches). Re-emitting
+// gives Monitor multiple chances to surface the line on a later idle tick.
+const PENDING_HEARTBEAT_MS = 60_000;
 
 // Short HH:MM:SS prefix so the Monitor output can be scanned at a glance.
 // Local time — Monitor's reader is always a human looking at one machine.
@@ -243,6 +248,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
     let heartbeatTimer = null;
     let refreshTimer = null;
     let freshnessTimer = null;
+    let pendingHeartbeatTimer = null;
     let lastEventAt = Date.now();
     let currentJwt = ticket.jwt;
     let settled = false;
@@ -253,6 +259,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
       if (refreshTimer) clearTimeout(refreshTimer);
       if (freshnessTimer) clearInterval(freshnessTimer);
+      if (pendingHeartbeatTimer) clearInterval(pendingHeartbeatTimer);
       try {
         ws.close();
       } catch (_) {}
@@ -311,6 +318,20 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
         }
       }, FRESHNESS_CHECK_INTERVAL_MS);
 
+      // Pending-inbox heartbeat. The Realtime INSERT push that triggers the
+      // initial "PATCHCORD: 1 new from <sender>" notification can be lost
+      // by the Monitor → agent-context surface layer if the agent happens
+      // to be mid-tool-call when the line is emitted (heavy agents with
+      // long tool calls — vector-DB search, CrossRef lookups — are most
+      // exposed). Re-emit the pending count once a minute as long as the
+      // inbox is non-empty so a later idle tick has another chance to
+      // wake the agent. drainQueueOnce stays silent if pending_count == 0.
+      pendingHeartbeatTimer = setInterval(() => {
+        drainQueueOnce(baseUrl, token).catch((e) => {
+          logErr(`subscribe: pending heartbeat failed: ${e.message}`);
+        });
+      }, PENDING_HEARTBEAT_MS);
+
       const scheduleRefresh = (ttlSec) => {
         const refreshIn = Math.max((ttlSec - JWT_REFRESH_SAFETY_MARGIN_SEC) * 1000, 30_000);
         refreshTimer = setTimeout(doRefresh, refreshIn);
@@ -372,6 +393,43 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       } catch {
         return;
       }
+
+      // Surface channel-state failures so silent server-side channel
+      // termination becomes visible. Previously we discarded every
+      // non-postgres_changes frame, which masked phx_join rejections,
+      // channel_error system messages, and post-refresh access_token
+      // rejections — exactly the cases where the WS stays "open" but
+      // realtime delivery is dead. Force a reconnect on any of those.
+      if (frame.event === "phx_reply") {
+        const status = frame.payload?.status;
+        if (status === "error") {
+          const reason = frame.payload?.response?.reason || frame.payload?.response || "unknown";
+          logErr(`subscribe: phx_reply error on topic=${frame.topic} ref=${frame.ref}: ${JSON.stringify(reason)}`);
+          done(new Error(`phx_reply error: ${JSON.stringify(reason)}`));
+          return;
+        }
+        return;
+      }
+      if (frame.event === "system") {
+        const status = frame.payload?.status;
+        const message = frame.payload?.message || frame.payload?.extension || "";
+        if (status === "error" || status === "channel_error") {
+          logErr(`subscribe: system error on topic=${frame.topic}: ${message}`);
+          done(new Error(`system error: ${message}`));
+          return;
+        }
+        // Successful subscribe ack — log once for confirmation, then quiet.
+        if (status === "ok" && message) {
+          logErr(`subscribe: system ok on ${frame.topic}: ${message}`);
+        }
+        return;
+      }
+      if (frame.event === "phx_error" || frame.event === "phx_close") {
+        logErr(`subscribe: ${frame.event} on topic=${frame.topic}: ${JSON.stringify(frame.payload || {})}`);
+        done(new Error(`${frame.event} on ${frame.topic}`));
+        return;
+      }
+
       if (frame.event !== "postgres_changes") return;
       const data = frame.payload?.data;
       if (!data || data.type !== "INSERT") return;