git-watchtower 2.3.16 → 2.3.17

package/bin/git-watchtower.js

@@ -878,7 +878,7 @@ const { parseDiffStats, stash: gitStash, stashPop: gitStashPop } = require('../s
 
 // Server process command parsing and static server utilities
 const { parseCommand } = require('../src/server/process');
-const { getMimeType, injectLiveReload, resolveStaticPath } = require('../src/server/static');
+const { getMimeType, injectLiveReload, resolveStaticPath, broadcastReload } = require('../src/server/static');
 
 // State (non-store globals)
 let previousBranchStates = new Map(); // branch name -> commit hash
@@ -2299,9 +2299,13 @@ function restartPolling() {
 
 function notifyClients() {
   if (NO_SERVER) return; // No clients in no-server mode
-  clients.forEach(client => client.write('data: reload\n\n'));
-  if (clients.size > 0) {
-    addLog(`Reloading ${clients.size} browser(s)`, 'info');
+  if (clients.size === 0) return;
+  const { delivered, dropped } = broadcastReload(clients);
+  if (delivered > 0) {
+    addLog(`Reloading ${delivered} browser(s)`, 'info');
+  }
+  if (dropped > 0) {
+    addLog(`Dropped ${dropped} dead live-reload client(s)`, 'warning');
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "2.3.16",
+  "version": "2.3.17",
   "description": "Terminal-based Git branch monitor with activity sparklines and optional dev server with live reload",
   "main": "bin/git-watchtower.js",
   "bin": {

package/src/server/static.js

@@ -125,10 +125,50 @@ function resolveStaticPath(candidate, realStaticDir) {
   return { status: 'ok', path: realPath };
 }
 
+/**
+ * Broadcast an SSE frame to every live-reload client, isolating per-client
+ * write failures so one dead socket can't abort the whole iteration.
+ *
+ * Previously this was a one-liner in bin/git-watchtower.js:
+ *   clients.forEach(c => c.write('data: reload\n\n'));
+ * If any client's underlying socket had been destroyed (browser tab
+ * closed, network reset, proxy hangup) without 'close' firing yet, the
+ * synchronous write threw `ERR_STREAM_DESTROYED` and aborted the
+ * forEach mid-iteration — every later client in the Set never received
+ * the reload event. Wrapping each write in try/catch and removing the
+ * failed client from the Set keeps the broadcast atomic-per-client and
+ * also prunes the dead entry so the next call doesn't trip on it again.
+ *
+ * @param {Set<{write: function, end?: function}>} clients - SSE response objects
+ * @param {string} [frame='data: reload\n\n'] - Pre-formatted SSE frame
+ * @returns {{delivered: number, dropped: number}}
+ */
+function broadcastReload(clients, frame) {
+  const message = frame || 'data: reload\n\n';
+  let delivered = 0;
+  let dropped = 0;
+  // Iterate a snapshot — Set.delete during forEach is safe in V8, but
+  // copying makes the contract explicit and survives any future
+  // iterator-protocol changes.
+  for (const client of Array.from(clients)) {
+    try {
+      client.write(message);
+      delivered++;
+    } catch (e) {
+      // Dead socket. Drop it and keep going so subsequent clients still
+      // see the broadcast.
+      clients.delete(client);
+      dropped++;
+    }
+  }
+  return { delivered, dropped };
+}
+
 module.exports = {
   MIME_TYPES,
   getMimeType,
   LIVE_RELOAD_SCRIPT,
   injectLiveReload,
   resolveStaticPath,
+  broadcastReload,
 };