git-watchtower 1.14.1 → 1.14.3

package/bin/git-watchtower.js

@@ -654,7 +654,7 @@ async function loadAsyncActionData(branch, currentData) {
     try {
       const host = new URL(env.webUrlBase).hostname;
       webUrl = buildBranchUrl(env.webUrlBase, host, branch.name);
-    } catch (e) { /* ignore */ }
+    } catch (e) { /* invalid webUrlBase — leave webUrl null, modal hides the link */ }
   }
 
   // Fetch session URL (local git, fast but async)
@@ -1963,7 +1963,7 @@ async function pollGitChanges() {
     }
 
     // Background ahead/behind fetch for visible branches
-    fetchAheadBehindForBranches(pollFilteredBranches).catch(() => {});
+    fetchAheadBehindForBranches(pollFilteredBranches).catch(() => { /* transient git/network error — next poll will retry */ });
 
     // AUTO-PULL: If current branch has remote updates, pull automatically (if enabled)
     const autoPullBranchName = store.get('currentBranch');
@@ -2447,7 +2447,7 @@ function setupKeyboardInput() {
                 store.setState({ actionData: fullData, actionLoading: false });
                 render();
               }
-            }).catch(() => {});
+            }).catch(() => { /* PR was created; modal refresh is a nice-to-have, user can reopen */ });
           } catch (e) {
             const msg = (e && e.stderr) || (e && e.message) || String(e);
             addLog(`Failed to create ${prLabel}: ${msg.split('\n')[0]}`, 'error');
@@ -2930,7 +2930,7 @@ function setupKeyboardInput() {
         } else {
           startWebDashboard(true).then(() => {
             showFlash(`Web dashboard on :${WEB_PORT}`);
-          }).catch(() => {});
+          }).catch(() => { /* startWebDashboard surfaces its own errors via addLog/showErrorToast */ });
         }
         break;
       }
@@ -3190,7 +3190,7 @@ async function startWebDashboard(openBrowser) {
   // Resolve and cache the repo web URL for link building in the web UI
   getRemoteWebUrl(null).then((url) => {
     if (url) webDashboard.setRepoWebUrl(url);
-  }).catch(() => {});
+  }).catch(() => { /* no remote or unreachable — web UI falls back to branch names without links */ });
 
   // Atomically try to claim the coordinator role. If another live instance
   // already owns the lock, connect as a worker instead. This prevents a
@@ -3317,10 +3317,10 @@ async function startWebDashboard(openBrowser) {
       webStateInterval = null;
     }
     if (webDashboard) {
-      try { webDashboard.stop(); } catch (_) { /* ignore */ }
+      try { webDashboard.stop(); } catch (_) { /* web server may not have bound yet — nothing to stop */ }
     }
     if (coordinator) {
-      try { coordinator.stop(); } catch (_) { /* ignore */ }
+      try { coordinator.stop(); } catch (_) { /* coordinator may not have started its IPC server */ }
     }
     removeLock();
     removeSocket();
@@ -3387,7 +3387,7 @@ function restartProcess() {
   // child can acquire it. The parent stays alive waiting on child.on('close'),
   // so without this the child sees the parent as an active owner and refuses.
   if (monitorLockFile) {
-    try { monitorLock.release(monitorLockFile); } catch (_) { /* ignore */ }
+    try { monitorLock.release(monitorLockFile); } catch (_) { /* lock file may have already been unlinked */ }
     monitorLockFile = null;
   }
 
@@ -3433,23 +3433,23 @@ function cleanupResources() {
 
   // Restore terminal first so the user sees a clean prompt even if a
   // later step throws.
-  try { write(ansi.showCursor); } catch (_) { /* ignore */ }
-  try { write(ansi.restoreScreen); } catch (_) { /* ignore */ }
-  try { restoreTerminalTitle(); } catch (_) { /* ignore */ }
-  try { if (process.stdin.isTTY) process.stdin.setRawMode(false); } catch (_) { /* ignore */ }
-  try { process.stdin.pause(); } catch (_) { /* ignore */ }
+  try { write(ansi.showCursor); } catch (_) { /* stdout may be closed during crash cleanup */ }
+  try { write(ansi.restoreScreen); } catch (_) { /* stdout may be closed during crash cleanup */ }
+  try { restoreTerminalTitle(); } catch (_) { /* stdout may be closed during crash cleanup */ }
+  try { if (process.stdin.isTTY) process.stdin.setRawMode(false); } catch (_) { /* stdin may already be unraw or detached */ }
+  try { process.stdin.pause(); } catch (_) { /* stdin may already be paused or destroyed */ }
 
   if (pollIntervalId) {
-    try { clearTimeout(pollIntervalId); } catch (_) { /* ignore */ }
+    try { clearTimeout(pollIntervalId); } catch (_) { /* defensive — clearTimeout normally won't throw */ }
     pollIntervalId = null;
   }
 
   if (periodicUpdateCheck) {
-    try { periodicUpdateCheck.stop(); } catch (_) { /* ignore */ }
+    try { periodicUpdateCheck.stop(); } catch (_) { /* interval handle may already be cleared */ }
   }
 
   if (fileWatcher) {
-    try { fileWatcher.close(); } catch (_) { /* ignore */ }
+    try { fileWatcher.close(); } catch (_) { /* watcher may already be closed by OS or previous cleanup */ }
     fileWatcher = null;
   }
 
@@ -3457,24 +3457,24 @@ function cleanupResources() {
   if (SERVER_MODE === 'static') {
     try {
       clients.forEach((client) => {
-        try { client.end(); } catch (_) { /* ignore */ }
+        try { client.end(); } catch (_) { /* SSE client socket already closed */ }
       });
       clients.clear();
-    } catch (_) { /* ignore */ }
+    } catch (_) { /* clients set may have mutated mid-iteration during shutdown */ }
   }
 
   // User's dev-server process (command mode)
   if (SERVER_MODE === 'command') {
-    try { stopServerProcess(); } catch (_) { /* ignore */ }
+    try { stopServerProcess(); } catch (_) { /* dev-server child may already be gone */ }
   }
 
   // Web dashboard + worker/coordinator (unlinks lock file + IPC socket)
-  try { stopWebDashboard(); } catch (_) { /* ignore */ }
+  try { stopWebDashboard(); } catch (_) { /* web dashboard may never have been started */ }
 
   // Per-repo monitor lock — release last so the slot stays reserved for the
   // entire lifetime of this process, including any errors in the steps above.
   if (monitorLockFile) {
-    try { monitorLock.release(monitorLockFile); } catch (_) { /* ignore */ }
+    try { monitorLock.release(monitorLockFile); } catch (_) { /* lock file may have been unlinked externally */ }
     monitorLockFile = null;
   }
 }
@@ -3523,9 +3523,9 @@ process.on('uncaughtException', async (err) => {
   // if telemetry shutdown hangs or throws.
   cleanupResources();
 
-  try { telemetry.captureError(err); } catch (_) { /* ignore */ }
+  try { telemetry.captureError(err); } catch (_) { /* telemetry must never prevent crash cleanup */ }
   console.error('Uncaught exception:', err);
-  try { await telemetry.shutdown(); } catch (_) { /* ignore */ }
+  try { await telemetry.shutdown(); } catch (_) { /* telemetry must never prevent crash cleanup */ }
   process.exit(1);
 });
 
@@ -3652,11 +3652,11 @@ async function start() {
 
   // Detect default branch for ahead/behind counts, then fetch initial data
   detectDefaultBranch().then(() => {
-    fetchAheadBehindForBranches(initBranches).catch(() => {});
-  }).catch(() => {});
+    fetchAheadBehindForBranches(initBranches).catch(() => { /* ahead/behind is background-only — stale counts are better than a noisy startup */ });
+  }).catch(() => { /* no default branch detectable (no remote refs yet) — ahead/behind stays hidden */ });
 
   // Load sparklines and action cache in background
-  refreshAllSparklines().catch(() => {});
+  refreshAllSparklines().catch(() => { /* sparkline cache stays empty — activity column just renders blank */ });
   initActionCache().then(() => {
     // Once env is known, kick off initial PR status fetch
     fetchAllPrStatuses().then(map => {
@@ -3665,8 +3665,8 @@ async function start() {
         lastPrStatusFetch = Date.now();
         render();
       }
-    }).catch(() => {});
-  }).catch(() => {});
+    }).catch(() => { /* gh/glab unreachable — inline PR indicators stay hidden, poller will retry */ });
+  }).catch(() => { /* cliEnv detection failed — PR actions fall back to web links where possible */ });
 
   // Start server based on mode
   const startBranchName = store.get('currentBranch');
@@ -3737,7 +3737,7 @@ async function start() {
       addLog(`New version available: ${latestVersion} \u2192 npm i -g git-watchtower`, 'update');
       render();
     }
-  }).catch(() => {});
+  }).catch(() => { /* npm registry unreachable — periodic check will try again in 4h */ });
 
   // Re-check for updates periodically (every 4 hours) while running.
   // Assigned to module scope so the top-level exit handler can stop it.

package/package.json

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

package/src/git/remote.js

@@ -77,7 +77,7 @@ function detectPlatform(webUrl) {
     if (host === 'gitlab.com' || parts.includes('gitlab')) return 'gitlab';
     if (host === 'bitbucket.org' || parts.includes('bitbucket')) return 'bitbucket';
     if (host === 'dev.azure.com' || host.endsWith('.visualstudio.com')) return 'azure';
-  } catch (e) { /* ignore */ }
+  } catch (e) { /* webUrl isn't a valid URL — fall through to the self-hosted default */ }
   return 'github'; // default assumption for self-hosted
 }
 

package/src/server/coordinator.js

@@ -161,14 +161,14 @@ function finalizeLock(pid, port, socketPath) {
  * Remove the lock file.
  */
 function removeLock() {
-  try { fs.unlinkSync(LOCK_FILE); } catch (e) { /* ignore */ }
+  try { fs.unlinkSync(LOCK_FILE); } catch (e) { /* lock file may not exist */ }
 }
 
 /**
  * Remove stale socket file.
  */
 function removeSocket() {
-  try { fs.unlinkSync(SOCKET_PATH); } catch (e) { /* ignore */ }
+  try { fs.unlinkSync(SOCKET_PATH); } catch (e) { /* socket file may not exist */ }
 }
 
 /**
@@ -255,7 +255,7 @@ class Coordinator {
   stop() {
     // Close all worker sockets
     for (const socket of this.workerSockets.values()) {
-      try { socket.destroy(); } catch (e) { /* ignore */ }
+      try { socket.destroy(); } catch (e) { /* socket may already be destroyed */ }
     }
     this.workerSockets.clear();
     this.projects.clear();
@@ -359,7 +359,7 @@ class Coordinator {
           try {
             const msg = JSON.parse(line);
             this._handleWorkerMessage(socket, msg, (id) => { workerId = id; }, () => workerId);
-          } catch (e) { /* ignore bad JSON */ }
+          } catch (e) { /* malformed IPC frame from worker — skip it and keep reading */ }
         }
       }
     });
@@ -445,7 +445,7 @@ class Coordinator {
   _sendMessage(socket, msg) {
     try {
       socket.write(JSON.stringify(msg) + '\n');
-    } catch (e) { /* ignore write errors on dead sockets */ }
+    } catch (e) { /* peer socket closed between iteration and write — peer will reconnect if it recovers */ }
   }
 
   /**
@@ -517,7 +517,7 @@ class Worker {
             try {
               const msg = JSON.parse(line);
               this._handleMessage(msg);
-            } catch (e) { /* ignore */ }
+            } catch (e) { /* malformed IPC frame from coordinator — skip it and keep reading */ }
           }
         }
       });
@@ -574,7 +574,7 @@ class Worker {
     if (this.socket && this._connected) {
       try {
         this.socket.write(JSON.stringify(msg) + '\n');
-      } catch (e) { /* ignore */ }
+      } catch (e) { /* coordinator socket closed between isConnected() check and write */ }
     }
   }
 

package/src/server/process.js

@@ -265,38 +265,13 @@ class ProcessManager {
       return false;
     }
 
-    // Capture reference before nulling — needed for deferred SIGKILL
+    // Capture reference before nulling — needed for deferred force-kill
     const proc = this.process;
 
-    // Try graceful shutdown first
     if (process.platform === 'win32') {
-      try {
-        spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t']);
-      } catch (e) {
-        // Ignore taskkill errors
-      }
+      this._stopWindows(proc);
     } else {
-      try {
-        // Kill the entire process group (negative PID) so that
-        // grandchildren (e.g. npm -> node -> vite) are also terminated.
-        process.kill(-proc.pid, 'SIGTERM');
-
-        // Force kill after grace period
-        const forceKillTimeout = setTimeout(() => {
-          try {
-            process.kill(-proc.pid, 'SIGKILL');
-          } catch (e) {
-            // Process group may already be dead
-          }
-        }, KILL_GRACE_PERIOD);
-
-        // Clear timeout if process exits cleanly
-        proc.once('close', () => {
-          clearTimeout(forceKillTimeout);
-        });
-      } catch (e) {
-        // Process group may already be dead
-      }
+      this._stopUnix(proc);
     }
 
     this.process = null;
@@ -305,6 +280,77 @@ class ProcessManager {
     return true;
   }
 
+  /**
+   * Unix stop: SIGTERM the process group, then SIGKILL after a grace period.
+   * The grace timer is unref'd so it doesn't keep the event loop alive when
+   * the main process wants to exit.
+   * @param {import('child_process').ChildProcess} proc
+   * @private
+   */
+  _stopUnix(proc) {
+    // If the process has already exited, there's nothing to signal.
+    if (proc.exitCode !== null || proc.signalCode !== null) return;
+
+    try {
+      process.kill(-proc.pid, 'SIGTERM');
+    } catch (e) {
+      // Process group may already be dead
+      return;
+    }
+
+    const forceKillTimeout = setTimeout(() => {
+      // Re-check: process may have exited during the grace period.
+      if (proc.exitCode !== null || proc.signalCode !== null) return;
+      try {
+        process.kill(-proc.pid, 'SIGKILL');
+      } catch (e) {
+        // Process group may already be dead
+      }
+    }, KILL_GRACE_PERIOD);
+
+    // Don't let this timer keep the event loop alive on shutdown.
+    forceKillTimeout.unref();
+
+    // Clear early if the process exits before the grace period.
+    proc.once('close', () => {
+      clearTimeout(forceKillTimeout);
+    });
+  }
+
+  /**
+   * Windows stop: taskkill /t (tree kill). If the process doesn't exit
+   * within the grace period, retry with /f (force).
+   * @param {import('child_process').ChildProcess} proc
+   * @private
+   */
+  _stopWindows(proc) {
+    if (proc.exitCode !== null || proc.signalCode !== null) return;
+
+    try {
+      spawn('taskkill', ['/pid', proc.pid.toString(), '/t']);
+    } catch (e) {
+      // Ignore spawn errors (PID already gone, etc.)
+      return;
+    }
+
+    // Fallback: force-kill if the process is still alive after the
+    // grace period. This mirrors the Unix SIGTERM → SIGKILL pattern.
+    const forceKillTimeout = setTimeout(() => {
+      if (proc.exitCode !== null || proc.signalCode !== null) return;
+      try {
+        spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t']);
+      } catch (e) {
+        // Ignore — process may already be dead
+      }
+    }, KILL_GRACE_PERIOD);
+
+    forceKillTimeout.unref();
+
+    proc.once('close', () => {
+      clearTimeout(forceKillTimeout);
+    });
+  }
+
   /**
    * Restart the server process
    * @returns {Promise<{success: boolean, error?: Error, pid?: number}>}

package/src/server/web-ui/js.js

@@ -70,7 +70,7 @@ function getDashboardJs() {
   function savePrefs(updates) {
     const prefs = loadPrefs();
     Object.keys(updates).forEach((k) => { prefs[k] = updates[k]; });
-    try { localStorage.setItem(PREFS_KEY, JSON.stringify(prefs)); } catch (e) { /* ignore */ }
+    try { localStorage.setItem(PREFS_KEY, JSON.stringify(prefs)); } catch (e) { /* localStorage quota exceeded or disabled (private mode) — prefs are best-effort */ }
     return prefs;
   }
   const prefs = loadPrefs();
@@ -122,7 +122,7 @@ function getDashboardJs() {
     try {
       const n = new Notification(title, { body, tag: tag || 'git-watchtower', icon: '', silent: false });
       setTimeout(() => n.close(), 8000);
-    } catch (e) { /* ignore */ }
+    } catch (e) { /* Notification constructor can throw on some browsers (e.g. permission revoked mid-session) */ }
   }
 
   function diffBranchesForNotifications(oldBranches, newBranches) {
@@ -232,14 +232,14 @@ function getDashboardJs() {
         }
         renderTabs();
         render();
-      } catch (err) { /* ignore parse errors */ }
+      } catch (err) { /* malformed SSE state frame — skip this push, next one will re-render */ }
     });
 
     evtSource.addEventListener('flash', (e) => {
       try {
         const data = JSON.parse(e.data);
         showFlash(data.text, data.type);
-      } catch (err) { /* ignore */ }
+      } catch (err) { /* malformed flash payload — not worth surfacing, skip */ }
     });
 
     evtSource.addEventListener('actionResult', (e) => {
@@ -251,7 +251,7 @@ function getDashboardJs() {
         } else {
           showToast(data.message, data.success ? 'success' : 'error');
         }
-      } catch (err) { /* ignore */ }
+      } catch (err) { /* malformed actionResult payload — skip (the action already ran server-side) */ }
     });
 
     evtSource.onerror = () => {
@@ -434,7 +434,7 @@ function getDashboardJs() {
           state.serverMode = pState.serverMode || 'none';
           state.repoWebUrl = pState.repoWebUrl || null;
           render();
-        } catch (err) { /* ignore */ }
+        } catch (err) { /* malformed per-project state response — keep current view until the next poll */ }
       }
     };
     xhr.send();
@@ -804,8 +804,8 @@ ${pureFnBlock}
     const btn = e.target.closest('.action-item');
     if (!btn) return;
     const key = btn.getAttribute('data-action-key');
-    const data = {};
-    try { data = JSON.parse(btn.getAttribute('data-action-data') || '{}'); } catch (err) { /* ignore */ }
+    let data = {};
+    try { data = JSON.parse(btn.getAttribute('data-action-data') || '{}'); } catch (err) { /* malformed data-action-data — fall through with empty object */ }
 
     hideBranchActions();
 

package/src/server/web.js

@@ -272,7 +272,7 @@ class WebDashboardServer {
 
     // Close all SSE connections
     for (const client of this.clients) {
-      try { client.end(); } catch (e) { /* ignore */ }
+      try { client.end(); } catch (e) { /* SSE client may already be disconnected */ }
     }
     this.clients.clear();
 
@@ -293,7 +293,7 @@ class WebDashboardServer {
       try {
         client.write('event: flash\n');
         client.write('data: ' + data + '\n\n');
-      } catch (e) { /* ignore dead clients */ }
+      } catch (e) { /* SSE client disconnected — will be pruned when its response closes */ }
     }
   }
 
@@ -307,7 +307,7 @@ class WebDashboardServer {
       try {
         client.write('event: preview\n');
         client.write('data: ' + json + '\n\n');
-      } catch (e) { /* ignore dead clients */ }
+      } catch (e) { /* SSE client disconnected — will be pruned when its response closes */ }
     }
   }
 
@@ -321,7 +321,7 @@ class WebDashboardServer {
       try {
         client.write('event: actionResult\n');
         client.write('data: ' + json + '\n\n');
-      } catch (e) { /* ignore dead clients */ }
+      } catch (e) { /* SSE client disconnected — will be pruned when its response closes */ }
     }
   }
 

package/src/utils/monitor-lock.js

@@ -74,7 +74,7 @@ function readLock(file) {
 }
 
 function removeLock(file) {
-  try { fs.unlinkSync(file); } catch (e) { /* ignore */ }
+  try { fs.unlinkSync(file); } catch (e) { /* lock file may not exist (already removed or never created) */ }
 }
 
 /**

package/src/utils/version-check.js

@@ -100,7 +100,7 @@ function startPeriodicUpdateCheck(onUpdateFound, interval = UPDATE_CHECK_INTERVA
       .then((latestVersion) => {
         if (latestVersion) onUpdateFound(latestVersion);
       })
-      .catch(() => {});
+      .catch(() => { /* npm registry unreachable — next scheduled tick will try again */ });
   }, interval);
 
   return { stop: () => clearInterval(timerId) };