git-watchtower 2.3.16 → 2.3.18

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.18",
   "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/coordinator.js

@@ -108,6 +108,24 @@ function ensureDir() {
 
 /**
  * Check if a process with the given PID is alive.
+ *
+ * `process.kill(pid, 0)` is the standard "is this PID alive?" probe. It
+ * sends signal 0 (no-op) and surfaces the kernel's answer via errno:
+ *
+ *   - resolves cleanly       → process exists and we can signal it
+ *   - throws ESRCH           → no such process; safe to call dead
+ *   - throws EPERM           → process exists but is owned by another
+ *                              user or in a different cgroup. STILL
+ *                              alive — we just can't signal it.
+ *
+ * Treating EPERM as "dead" was a real bug for the coordinator lock: if
+ * a coordinator's PID was reused by another local user's process after
+ * a crash, a peer instance would read the lock, see EPERM, decide the
+ * coordinator was dead, unlink the lock, and try to take over while
+ * the original (or reused) PID was still running. Mirroring the same
+ * EPERM-aware check used by src/utils/monitor-lock.js prevents that
+ * cleanup-then-clobber race.
+ *
  * @param {number} pid
  * @returns {boolean}
  */
@@ -116,7 +134,8 @@ function isProcessAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (e) {
-    return false;
+    // ESRCH = no such process; EPERM = exists but owned by another user.
+    return e.code === 'EPERM';
   }
 }
 

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,
 };