git-watchtower 1.14.11 → 1.14.13

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;
 
@@ -3644,6 +3666,20 @@ process.on('unhandledRejection', async (reason) => {
 // ============================================================================
 
 async function start() {
+  // git-watchtower is a full-screen TUI. If stdout isn't a TTY (piped to a
+  // file, `tee`, `head`, or captured by a non-interactive CI runner) every
+  // frame writes hideCursor/clearScreen/moveTo/color escapes into the pipe,
+  // producing an unreadable log and wasting CPU on a render loop no human
+  // will see. Refuse to start and point the user at a sensible alternative.
+  if (!process.stdout.isTTY) {
+    console.error('git-watchtower: stdout is not a TTY.');
+    console.error('');
+    console.error('  This is an interactive terminal UI and cannot render when stdout is');
+    console.error('  piped or redirected. If you only need a CI-friendly status check,');
+    console.error('  use `git fetch` + `git log` directly.');
+    process.exit(1);
+  }
+
   // Check if git is available
   const gitAvailable = await checkGitAvailable();
   if (!gitAvailable) {

package/package.json

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

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