patchcord 0.5.32 → 0.5.33

package/package.json

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

package/scripts/subscribe.mjs

@@ -23,19 +23,27 @@ const RECONNECT_BACKOFF_MS = [1000, 2000, 4000, 8000, 15_000, 30_000];
 const FRESHNESS_CHECK_INTERVAL_MS = 30_000;
 const FRESHNESS_STALE_MS = 90_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.
+function logErr(msg) {
+  const d = new Date();
+  const ts = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+  process.stderr.write(`[${ts}] ${msg}\n`);
+}
+
 // Guarantee a terminal stderr line on any unhandled failure so the agent
 // reading Monitor's output file always sees WHY the process died.
 process.on("uncaughtException", (err) => {
-  process.stderr.write(`subscribe: fatal: uncaught: ${err?.stack || err?.message || err}\n`);
+  logErr(`subscribe: fatal: uncaught: ${err?.stack || err?.message || err}`);
   process.exit(1);
 });
 process.on("unhandledRejection", (err) => {
-  process.stderr.write(`subscribe: fatal: unhandled rejection: ${err?.stack || err?.message || err}\n`);
+  logErr(`subscribe: fatal: unhandled rejection: ${err?.stack || err?.message || err}`);
   process.exit(1);
 });
 
 function die(msg, code = 1) {
-  process.stderr.write(msg + "\n");
+  logErr(msg);
   process.exit(code);
 }
 
@@ -178,7 +186,7 @@ function removePidfile(path) {
 async function run() {
   const cwd = process.cwd();
   const { baseUrl, token } = readMcpConfig(cwd);
-  process.stderr.write(`subscribe: cwd=${cwd} server=${baseUrl}\n`);
+  logErr(`subscribe: cwd=${cwd} server=${baseUrl}`);
 
   let ticket = await fetchTicket(baseUrl, token);
   const pidfile = `/tmp/patchcord_subscribe_${ticket.namespace_ids[0]}_${ticket.agent_id}.pid`;
@@ -195,9 +203,7 @@ async function run() {
     process.exit(0);
   });
 
-  process.stderr.write(
-    `subscribe: agent=${ticket.agent_id} namespaces=${ticket.namespace_ids.join(",")}\n`
-  );
+  logErr(`subscribe: agent=${ticket.agent_id} namespaces=${ticket.namespace_ids.join(",")}`);
 
   let backoffIdx = 0;
 
@@ -210,16 +216,16 @@ async function run() {
         });
         backoffIdx = 0; // clean disconnect resets backoff
       } catch (e) {
-        process.stderr.write(`subscribe: ${e.message}\n`);
+        logErr(`subscribe: ${e.message}`);
       }
       const delay = RECONNECT_BACKOFF_MS[Math.min(backoffIdx, RECONNECT_BACKOFF_MS.length - 1)];
       backoffIdx++;
-      process.stderr.write(`subscribe: reconnecting in ${delay}ms\n`);
+      logErr(`subscribe: reconnecting in ${delay}ms`);
       await new Promise((r) => setTimeout(r, delay));
       try {
         ticket = await fetchTicket(baseUrl, token);
       } catch (e) {
-        process.stderr.write(`subscribe: ticket refresh failed: ${e.message}\n`);
+        logErr(`subscribe: ticket refresh failed: ${e.message}`);
       }
     }
   };
@@ -255,7 +261,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
     };
 
     ws.on("open", () => {
-      process.stderr.write("subscribe: connected\n");
+      logErr("subscribe: connected");
       for (const topic of ticket.topics) {
         ws.send(
           JSON.stringify({
@@ -277,7 +283,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       // 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`);
+        logErr(`subscribe: queue check failed: ${e.message}`);
       });
       heartbeatTimer = setInterval(() => {
         try {
@@ -300,9 +306,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       freshnessTimer = setInterval(() => {
         const stale = Date.now() - lastEventAt;
         if (stale > FRESHNESS_STALE_MS) {
-          process.stderr.write(
-            `subscribe: ws stale ${Math.round(stale / 1000)}s, forcing reconnect\n`
-          );
+          logErr(`subscribe: ws stale ${Math.round(stale / 1000)}s, forcing reconnect`);
           done(new Error(`ws stale ${Math.round(stale / 1000)}s`));
         }
       }, FRESHNESS_CHECK_INTERVAL_MS);
@@ -340,13 +344,16 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
               })
             );
           }
-          process.stderr.write("subscribe: token refreshed\n");
+          // Routine refresh success — don't log. Over days this fills the
+          // Monitor output with ~250 identical lines and buries the rare
+          // interesting events (connects, errors). Refresh failures DO log,
+          // because those are the ones worth scanning for.
           scheduleRefresh(fresh.jwt_expires_in);
         } catch (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`);
+          logErr(`subscribe: token refresh failed, retrying in 30s: ${e.message}`);
           refreshTimer = setTimeout(doRefresh, 30_000);
         }
       };
@@ -384,20 +391,20 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
     });
 
     ws.on("error", (err) => {
-      process.stderr.write(`subscribe: ws error: ${err.message}\n`);
+      logErr(`subscribe: ws error: ${err.message}`);
       done(err);
     });
 
     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`);
+      logErr(`subscribe: ws closed (${codeStr}${reasonStr})`);
       done();
     });
   });
 }
 
 run().catch((e) => {
-  process.stderr.write(`subscribe: fatal: ${e.message}\n`);
+  logErr(`subscribe: fatal: ${e.message}`);
   process.exit(1);
 });