git-watchtower 2.3.17 → 2.3.19

package/bin/git-watchtower.js

@@ -1881,18 +1881,24 @@ async function pollGitChanges() {
   // Skip if a poll is already in progress (don't queue)
   if (pollMutex.isLocked()) return;
   const pollToken = await pollMutex.acquire();
-  store.setState({ isPolling: true, pollingStatus: 'fetching' });
 
-  // Casino mode: start slot reels spinning (no sound - too annoying)
-  if (store.get('casinoModeEnabled')) {
-    casino.startSlotReels(render);
-  }
+  // Everything past acquire() must be wrapped so the finally releases
+  // the token. The previous shape kept the setState / casino.startSlotReels
+  // / render() calls outside the try, so a throw from any of them (e.g. a
+  // store middleware error, a casino interval-setup failure) leaked the
+  // mutex permanently and stalled every subsequent poll cycle.
+  try {
+    store.setState({ isPolling: true, pollingStatus: 'fetching' });
 
-  render();
+    // Casino mode: start slot reels spinning (no sound - too annoying)
+    if (store.get('casinoModeEnabled')) {
+      casino.startSlotReels(render);
+    }
 
-  const fetchStartTime = Date.now();
+    render();
+
+    const fetchStartTime = Date.now();
 
-  try {
     const newCurrentBranch = await getCurrentBranch();
     const prevCurrentBranch = store.get('currentBranch');
 
@@ -2004,12 +2010,10 @@ async function pollGitChanges() {
     const updatedBranches = [];
     const updatedBranchPrevCommits = new Map();
     const currentBranchName = store.get('currentBranch');
-    const activeBranchNames = new Set();
     for (const branch of pollFilteredBranches) {
       // Clear previous cycle's flag so only freshly-updated branches are highlighted
       branch.justUpdated = false;
       if (branch.isDeleted) continue;
-      activeBranchNames.add(branch.name);
       const prevCommit = previousBranchStates.get(branch.name);
       if (prevCommit && prevCommit !== branch.commit && branch.name !== currentBranchName) {
         updatedBranches.push(branch);
@@ -2019,17 +2023,13 @@ async function pollGitChanges() {
       previousBranchStates.set(branch.name, branch.commit);
     }
 
-    // Remove stale entries from caches for branches
-    // that no longer exist in the current poll results
-    const staleCaches = [previousBranchStates, prInfoCache, store.get('sparklineCache'), store.get('aheadBehindCache')];
-    for (const cache of staleCaches) {
-      if (!cache) continue;
-      for (const name of cache.keys()) {
-        if (!activeBranchNames.has(name)) {
-          cache.delete(name);
-        }
-      }
-    }
+    // (No second prune pass here — pruneStaleEntries above already prunes
+    // these four caches against fetchedBranchNames with a 30 s deleted-
+    // branch grace period. The previous extra loop pruned against the
+    // active-only set instead, which excluded isDeleted entries and so
+    // wiped a recently-deleted branch's sparkline / PR status / ahead-
+    // behind data IMMEDIATELY — contradicting the retention window the
+    // first prune was specifically designed to provide.)
 
     // Flash and sound for updates or new branches
     const casinoOn = store.get('casinoModeEnabled');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "2.3.17",
+  "version": "2.3.19",
   "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';
   }
 }