git-watchtower 1.14.12 → 1.14.14

package/bin/git-watchtower.js

@@ -103,6 +103,7 @@ const store = new Store();
 const { WebDashboardServer } = require('../src/server/web');
 const { Coordinator, Worker, generateProjectId, getActiveCoordinator, tryAcquireLock, finalizeLock, removeLock, removeSocket, isProcessAlive } = require('../src/server/coordinator');
 const monitorLock = require('../src/utils/monitor-lock');
+const { createPipeErrorHandler } = require('../src/utils/pipe-error');
 
 const PROJECT_ROOT = process.cwd();
 
@@ -3602,6 +3603,27 @@ process.on('SIGTERM', shutdown);
 process.on('exit', () => {
   cleanupResources();
 });
+
+// Defense-in-depth against a stdio pipe closing mid-run. The #13 TTY guard
+// stops `git-watchtower | head` at startup, but a TTY can still disappear
+// later (SSH drops, terminal window closes, pty tears down). Without this,
+// the next write() emits an async EPIPE which Node promotes to
+// uncaughtException — producing a crash report and telemetry noise for
+// what is a benign pipe-closed condition.
+const stdioPipeErrorHandler = createPipeErrorHandler({
+  onEpipe: () => {
+    isShuttingDown = true;
+    try { cleanupResources(); } catch (_) { /* best-effort during pipe-close */ }
+    process.exit(0);
+  },
+  onOther: (err) => {
+    // Any other stdio error is unexpected — re-raise so the existing
+    // uncaughtException handler can capture telemetry and restore terminal.
+    setImmediate(() => { throw err; });
+  },
+});
+process.stdout.on('error', stdioPipeErrorHandler);
+process.stderr.on('error', stdioPipeErrorHandler);
 process.on('uncaughtException', async (err) => {
   isShuttingDown = true;
 

package/package.json

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

package/src/casino/index.js

@@ -41,6 +41,7 @@ let slotResultFlashFrame = 0;    // Flash animation frame
 let slotResultInterval = null;   // Interval for result display/flash
 let slotResultRenderCallback = null; // Callback for re-rendering
 let slotResultLabel = null;      // "NOTHING", "WIN", "BIG WIN", "JACKPOT" etc
+let slotResultClearTimeout = null; // No-win 2s auto-clear timer handle
 
 // Win animation state
 let winAnimationFrame = 0;
@@ -98,10 +99,42 @@ function enable() {
 function disable() {
   casinoEnabled = false;
   stopMarquee();
-  stopSlotReels();
+  // resetSlotState — not stopSlotReels — because stopSlotReels() runs the
+  // end-of-poll result animation (labels a "NOTHING" panel and schedules a
+  // 2s auto-clear). Calling that during disable paints a brand-new casino
+  // effect on the way out, which the user just asked to stop.
+  resetSlotState();
   stopWinAnimation();
 }
 
+/**
+ * Clear all slot reel state and timers without scheduling any new effects.
+ * Safe to call from disable() — unlike stopSlotReels(), it does not kick
+ * off a result display or a delayed clear timer.
+ * @private
+ */
+function resetSlotState() {
+  if (slotReelInterval) {
+    clearInterval(slotReelInterval);
+    slotReelInterval = null;
+  }
+  if (slotResultInterval) {
+    clearInterval(slotResultInterval);
+    slotResultInterval = null;
+  }
+  if (slotResultClearTimeout) {
+    clearTimeout(slotResultClearTimeout);
+    slotResultClearTimeout = null;
+  }
+  isSpinning = false;
+  slotReelFrame = 0;
+  slotResult = null;
+  slotResultIsWin = false;
+  slotResultFlashFrame = 0;
+  slotResultLabel = null;
+  slotResultRenderCallback = null;
+}
+
 /**
  * Toggle casino mode
  * @returns {boolean} New state
@@ -312,8 +345,11 @@ function stopSlotReels(hadUpdates = false, renderCallback = null, winLevel = nul
       slotResult.push(SLOT_SYMBOLS[idx]);
     }
 
-    // Display for 2 seconds then fade
-    setTimeout(() => {
+    // Display for 2 seconds then fade. Store the handle so disable() /
+    // resetSlotState() can cancel it — otherwise a delayed clear fires
+    // mid-way through the next enabled session and nulls live state.
+    slotResultClearTimeout = setTimeout(() => {
+      slotResultClearTimeout = null;
       slotResult = null;
       slotResultLabel = null;
       if (slotResultRenderCallback) slotResultRenderCallback();
@@ -326,6 +362,7 @@ function stopSlotReels(hadUpdates = false, renderCallback = null, winLevel = nul
  * @returns {Object|null}
  */
 function getSlotResultLabel() {
+  if (!casinoEnabled) return null;
   return slotResultLabel;
 }
 
@@ -334,6 +371,7 @@ function getSlotResultLabel() {
  * @returns {boolean}
  */
 function isSlotSpinning() {
+  if (!casinoEnabled) return false;
   return isSpinning;
 }
 
@@ -342,6 +380,7 @@ function isSlotSpinning() {
  * @returns {boolean}
  */
 function hasSlotResult() {
+  if (!casinoEnabled) return false;
   return slotResult !== null;
 }
 
@@ -350,6 +389,7 @@ function hasSlotResult() {
  * @returns {boolean}
  */
 function isSlotsActive() {
+  if (!casinoEnabled) return false;
   return isSpinning || slotResult !== null;
 }
 
@@ -358,6 +398,10 @@ function isSlotsActive() {
  * @returns {string}
  */
 function getSlotReelDisplay() {
+  // Defense-in-depth: even if stale state survived a disable/enable cycle,
+  // don't paint casino UI when the mode is off.
+  if (!casinoEnabled) return '';
+
   // Show result if we have one
   if (slotResult) {
     const reels = [];

package/src/utils/pipe-error.js

@@ -0,0 +1,43 @@
+/**
+ * Stdio pipe error handling.
+ *
+ * The TUI writes ANSI frames to stdout continuously. If the downstream
+ * consumer goes away — SSH drops, the terminal window closes, or the
+ * user intentionally short-circuits via `| head` on a non-guarded
+ * invocation — the next write() emits an async 'error' event with
+ * code EPIPE on the stream. Without a handler, Node promotes that to
+ * uncaughtException, which logs a crash report, generates telemetry
+ * noise, and clutters the user's prompt on exit.
+ *
+ * A normal pipe-closed condition is not a crash; the correct response
+ * is to clean up and exit quietly with status 0.
+ *
+ * @module utils/pipe-error
+ */
+
+'use strict';
+
+/**
+ * Build an 'error' handler for process.stdout / process.stderr.
+ *
+ * @param {Object} callbacks
+ * @param {() => void} callbacks.onEpipe - Invoked when the pipe is closed
+ *   from the other end. Typically runs cleanupResources() and exits 0.
+ * @param {(err: Error) => void} callbacks.onOther - Invoked for any other
+ *   stream error. Typically re-raises via setImmediate so the existing
+ *   uncaughtException handler can capture telemetry.
+ * @returns {(err: Error & { code?: string }) => void}
+ */
+function createPipeErrorHandler({ onEpipe, onOther }) {
+  return function pipeErrorHandler(err) {
+    if (err && err.code === 'EPIPE') {
+      onEpipe();
+      return;
+    }
+    onOther(err);
+  };
+}
+
+module.exports = {
+  createPipeErrorHandler,
+};