patchcord 0.5.3 → 0.5.5

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "patchcord",
   "description": "Cross-machine agent messaging with push delivery. Messages from other agents arrive as native channel notifications.",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "author": {
     "name": "ppravdin"
   },

package/package.json

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

package/scripts/lib/ws.mjs

@@ -68,7 +68,7 @@ export function connect(urlStr, { headers = {} } = {}) {
   socket.on("close", () => {
     if (!closed) {
       closed = true;
-      emitter.emit("close");
+      emitter.emit("close", { code: null, reason: "socket-ended" });
     }
   });
 
@@ -115,8 +115,16 @@ export function connect(urlStr, { headers = {} } = {}) {
       if (opcode === 0x1) {
         emitter.emit("message", payload.toString("utf8"));
       } else if (opcode === 0x8) {
-        // close frame
-        emitter.emit("close");
+        // close frame — parse code/reason for diagnostics
+        let code = null;
+        let reason = "";
+        if (payload.length >= 2) {
+          code = payload.readUInt16BE(0);
+          if (payload.length > 2) {
+            reason = payload.slice(2).toString("utf8");
+          }
+        }
+        emitter.emit("close", { code, reason });
         closed = true;
         try {
           socket.write(encodeFrame(0x8, closePayload(1000, ""), true));

package/scripts/subscribe.mjs

@@ -102,6 +102,27 @@ async function fetchTicket(baseUrl, token) {
   }
 }
 
+// Check if there are messages already pending in the inbox at the moment
+// we connect (or reconnect). Realtime only delivers FUTURE INSERTs, so
+// anything queued before we joined is invisible until the agent calls
+// inbox() manually. Emit a stdout line when there's a pending queue so
+// Monitor wakes the agent the same way a real arrival does.
+async function drainQueueOnce(baseUrl, token) {
+  const res = await httpJson(`${baseUrl}/api/inbox?count_only=1&limit=100`, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (res.status !== 200) {
+    throw new Error(`inbox HTTP ${res.status}`);
+  }
+  let count = 0;
+  try {
+    count = JSON.parse(res.body).pending_count ?? 0;
+  } catch (_) {}
+  if (count > 0) {
+    process.stdout.write(`PATCHCORD: ${count} waiting in inbox\n`);
+  }
+}
+
 function writePidfile(path) {
   try {
     writeFileSync(path, String(process.pid), { flag: "wx" });
@@ -233,6 +254,16 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
           })
         );
       }
+
+      // Drain any messages already in the queue when we connected.
+      // Realtime only delivers FUTURE INSERTs — anything pending before
+      // we joined (or that arrived during a reconnect gap) wouldn't
+      // otherwise wake the agent. Fire-and-forget: a transient HTTP
+      // failure here just means we miss queued messages this round;
+      // the next reconnect retries.
+      drainQueueOnce(baseUrl, token).catch((e) => {
+        process.stderr.write(`subscribe: queue check failed: ${e.message}\n`);
+      });
       heartbeatTimer = setInterval(() => {
         try {
           ws.send(
@@ -246,14 +277,29 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
         } catch (_) {}
       }, HEARTBEAT_INTERVAL_MS);
 
-      const refreshIn = Math.max(
-        (ticket.jwt_expires_in - JWT_REFRESH_SAFETY_MARGIN_SEC) * 1000,
-        30_000
-      );
-      refreshTimer = setTimeout(async () => {
+      const scheduleRefresh = (ttlSec) => {
+        const refreshIn = Math.max((ttlSec - JWT_REFRESH_SAFETY_MARGIN_SEC) * 1000, 30_000);
+        refreshTimer = setTimeout(doRefresh, refreshIn);
+      };
+
+      const doRefresh = async () => {
+        if (settled) return;
         try {
           const fresh = await refreshTicket();
           currentJwt = fresh.jwt;
+          // Socket-level auth update (phoenix topic) — what Supabase
+          // actually uses for the connection's own JWT expiry check.
+          // Without this, the server closes the socket at the original
+          // JWT's exp regardless of per-channel updates.
+          ws.send(
+            JSON.stringify({
+              topic: "phoenix",
+              event: "access_token",
+              payload: { access_token: currentJwt },
+              ref: String(ref++),
+            })
+          );
+          // Channel-level updates — matches supabase-js's setAuth() pattern.
           for (const topic of fresh.topics) {
             ws.send(
               JSON.stringify({
@@ -265,11 +311,17 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
             );
           }
           process.stderr.write("subscribe: token refreshed\n");
+          scheduleRefresh(fresh.jwt_expires_in);
         } catch (e) {
-          process.stderr.write(`subscribe: token refresh failed: ${e.message}\n`);
-          done(e);
+          // Transient network/server error — do NOT close the live
+          // connection. The current JWT is still valid for ~2 more min
+          // (JWT_REFRESH_SAFETY_MARGIN_SEC). Retry sooner.
+          process.stderr.write(`subscribe: token refresh failed, retrying in 30s: ${e.message}\n`);
+          refreshTimer = setTimeout(doRefresh, 30_000);
         }
-      }, refreshIn);
+      };
+
+      scheduleRefresh(ticket.jwt_expires_in);
     });
 
     ws.on("message", (raw) => {
@@ -297,8 +349,10 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       done(err);
     });
 
-    ws.on("close", () => {
-      process.stderr.write("subscribe: ws closed\n");
+    ws.on("close", (info) => {
+      const codeStr = info?.code != null ? `code=${info.code}` : "code=none";
+      const reasonStr = info?.reason ? ` reason=${JSON.stringify(info.reason)}` : "";
+      process.stderr.write(`subscribe: ws closed (${codeStr}${reasonStr})\n`);
       done();
     });
   });