git-watchtower 2.3.9 → 2.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "2.3.9",
+  "version": "2.3.11",
   "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/web.js

@@ -36,6 +36,16 @@ const MAX_PORT_RETRIES = 20;
  */
 const SSE_KEEPALIVE_INTERVAL = 15000;
 
+/**
+ * Maximum number of consecutive periodic-state pushes a stalled client (one
+ * whose internal write buffer hasn't drained) is allowed to miss before we
+ * force-close it. At a 500 ms STATE_PUSH_INTERVAL this gives roughly 30 s
+ * of grace before eviction — enough for a paused tab to wake up, short
+ * enough that a permanently dead socket can't pin memory or keep
+ * `clientCount` misleadingly high.
+ */
+const MAX_STALLED_PUSHES = 60;
+
 /**
  * Actions the web dashboard is allowed to POST to /api/action. Every entry
  * here MUST be matched by a `case` in `handleWebAction` in bin/git-watchtower.js
@@ -86,6 +96,15 @@ class WebDashboardServer {
     /** @type {Set<import('net').Socket>} Raw TCP sockets, tracked so stop() can force-close them */
     this._sockets = new Set();
 
+    /**
+     * Per-client count of consecutive state pushes skipped because the
+     * client's internal buffer hasn't drained. Reset to 0 on a successful
+     * write; a paused tab whose count crosses MAX_STALLED_PUSHES gets
+     * evicted to bound memory.
+     * @type {WeakMap<import('http').ServerResponse, number>}
+     */
+    this._stalledPushes = new WeakMap();
+
     // Multi-project support (populated by coordinator)
     /** @type {Map<string, Object>} */
     this.projects = new Map();
@@ -341,11 +360,9 @@ class WebDashboardServer {
    */
   flash(text, type) {
     const data = JSON.stringify({ text, type: type || 'info' });
+    const message = 'event: flash\ndata: ' + data + '\n\n';
     for (const client of this.clients) {
-      try {
-        client.write('event: flash\n');
-        client.write('data: ' + data + '\n\n');
-      } catch (e) { /* SSE client disconnected — will be pruned when its response closes */ }
+      this._writeToClient(client, message);
     }
   }
 
@@ -355,11 +372,9 @@ class WebDashboardServer {
    */
   sendPreview(data) {
     const json = JSON.stringify(data);
+    const message = 'event: preview\ndata: ' + json + '\n\n';
     for (const client of this.clients) {
-      try {
-        client.write('event: preview\n');
-        client.write('data: ' + json + '\n\n');
-      } catch (e) { /* SSE client disconnected — will be pruned when its response closes */ }
+      this._writeToClient(client, message);
     }
   }
 
@@ -369,14 +384,51 @@ class WebDashboardServer {
    */
   sendActionResult(result) {
     const json = JSON.stringify(result);
+    const message = 'event: actionResult\ndata: ' + json + '\n\n';
     for (const client of this.clients) {
-      try {
-        client.write('event: actionResult\n');
-        client.write('data: ' + json + '\n\n');
-      } catch (e) { /* SSE client disconnected — will be pruned when its response closes */ }
+      this._writeToClient(client, message);
     }
   }
 
+  /**
+   * Write a frame to a single SSE client, respecting backpressure.
+   * Skips the write when the client's internal buffer hasn't drained
+   * (`writableNeedDrain`), so a paused tab can't cause unbounded
+   * server-side queueing. Drops the client on synchronous write errors
+   * (most often "write after end" on an abruptly-closed socket).
+   *
+   * @param {import('http').ServerResponse} client
+   * @param {string} message - Pre-formatted SSE frame (event + data + \n\n)
+   * @returns {boolean} `true` if the write was issued, `false` if skipped or failed
+   * @private
+   */
+  _writeToClient(client, message) {
+    if (client.writableNeedDrain) {
+      // Client hasn't acknowledged earlier writes — skip this frame so
+      // backpressure doesn't accumulate. The next push retries naturally.
+      return false;
+    }
+    try {
+      client.write(message);
+      this._stalledPushes.set(client, 0);
+      return true;
+    } catch (e) {
+      this._dropClient(client);
+      return false;
+    }
+  }
+
+  /**
+   * Force-close and forget a client. Idempotent.
+   * @param {import('http').ServerResponse} client
+   * @private
+   */
+  _dropClient(client) {
+    try { client.end(); } catch (_) { /* already torn down */ }
+    this.clients.delete(client);
+    this._stalledPushes.delete(client);
+  }
+
   /**
    * Get the number of connected web clients.
    * @returns {number}
@@ -586,8 +638,22 @@ class WebDashboardServer {
 
     const message = 'event: state\ndata: ' + json + '\n\n';
     for (const client of this.clients) {
+      if (client.writableNeedDrain) {
+        // Backpressure: client's internal buffer hasn't drained from a
+        // previous write. Track how many consecutive periodic pushes
+        // we've skipped so a paused/dead tab can't accumulate stalled
+        // writes forever. The non-periodic emitters (flash/preview/
+        // actionResult) skip silently — only `_pushState` evicts.
+        const n = (this._stalledPushes.get(client) || 0) + 1;
+        this._stalledPushes.set(client, n);
+        if (n >= MAX_STALLED_PUSHES) {
+          this._dropClient(client);
+        }
+        continue;
+      }
       try {
         client.write(message);
+        this._stalledPushes.set(client, 0);
       } catch (e) {
         // Write failed — proactively prune the dead client instead of
         // waiting for req.on('close') to fire. On abrupt socket resets
@@ -595,8 +661,7 @@ class WebDashboardServer {
         // hit the same failed write, accumulating exception work and
         // keeping clientCount misleadingly high. Set.delete during
         // iteration is safe; the for-of iterator handles it.
-        try { client.end(); } catch (_) { /* already torn down */ }
-        this.clients.delete(client);
+        this._dropClient(client);
       }
     }
   }
@@ -606,5 +671,6 @@ module.exports = {
   WebDashboardServer,
   DEFAULT_WEB_PORT,
   STATE_PUSH_INTERVAL,
+  MAX_STALLED_PUSHES,
   ALLOWED_ACTIONS,
 };

package/src/ui/ansi.js

@@ -358,12 +358,106 @@ function sanitizeForRender(str) {
 }
 
 /**
- * Get the visible length of a string (excluding ANSI codes)
- * @param {string} str - String potentially containing ANSI codes
- * @returns {number} Visible character count
+ * Display width of a single Unicode code point in terminal columns.
+ * Returns 0 for combining marks / variation selectors / ZWJ, 2 for East
+ * Asian Wide / Fullwidth and emoji-presentation code points, 1 otherwise.
+ * Used by visibleLength's grapheme iterator.
+ * @param {number} cp
+ * @returns {number}
+ * @private
+ */
+function _codePointWidth(cp) {
+  if (cp == null) return 0;
+  // C0 / DEL — defensively zero-width (stripAnsi already drops them).
+  if (cp < 0x20 || cp === 0x7f) return 0;
+
+  // Combining marks, variation selectors, ZWJ — zero-width.
+  if (
+    (cp >= 0x0300 && cp <= 0x036F) ||  // Combining Diacritical Marks
+    (cp >= 0x1AB0 && cp <= 0x1AFF) ||  // Combining Diacritical Marks Extended
+    (cp >= 0x1DC0 && cp <= 0x1DFF) ||  // Combining Diacritical Marks Supplement
+    (cp >= 0x20D0 && cp <= 0x20FF) ||  // Combining Diacritical Marks for Symbols
+    (cp >= 0xFE00 && cp <= 0xFE0F) ||  // Variation Selectors (incl. emoji presentation)
+    (cp >= 0xFE20 && cp <= 0xFE2F) ||  // Combining Half Marks
+    cp === 0x200D                       // ZWJ
+  ) return 0;
+
+  // East Asian Wide / Fullwidth / emoji — two columns.
+  if (
+    (cp >= 0x1100 && cp <= 0x115F) ||  // Hangul Jamo
+    (cp >= 0x2E80 && cp <= 0x303E) ||  // CJK Radicals etc
+    (cp >= 0x3041 && cp <= 0x33FF) ||  // CJK Symbols / Hiragana / Katakana / Bopomofo / Hangul / CJK
+    (cp >= 0x3400 && cp <= 0x4DBF) ||  // CJK Unified Ideographs Ext A
+    (cp >= 0x4E00 && cp <= 0x9FFF) ||  // CJK Unified Ideographs
+    (cp >= 0xA000 && cp <= 0xA4CF) ||  // Yi Syllables
+    (cp >= 0xAC00 && cp <= 0xD7A3) ||  // Hangul Syllables
+    (cp >= 0xF900 && cp <= 0xFAFF) ||  // CJK Compatibility Ideographs
+    (cp >= 0xFE30 && cp <= 0xFE4F) ||  // CJK Compatibility Forms
+    (cp >= 0xFF00 && cp <= 0xFF60) ||  // Fullwidth Forms
+    (cp >= 0xFFE0 && cp <= 0xFFE6) ||  // Fullwidth Signs
+    (cp >= 0x1F300 && cp <= 0x1F5FF) || // Misc Symbols and Pictographs
+    (cp >= 0x1F600 && cp <= 0x1F64F) || // Emoticons
+    (cp >= 0x1F680 && cp <= 0x1F6FF) || // Transport
+    (cp >= 0x1F900 && cp <= 0x1F9FF) || // Supplemental Symbols and Pictographs
+    (cp >= 0x1FA00 && cp <= 0x1FAFF) || // Symbols and Pictographs Extended-A
+    (cp >= 0x1F1E6 && cp <= 0x1F1FF) || // Regional indicators (flags)
+    (cp >= 0x1F3FB && cp <= 0x1F3FF) || // Emoji modifiers (skin tone)
+    (cp >= 0x20000 && cp <= 0x2FFFD) || // CJK Ideographs Extension B-F
+    (cp >= 0x30000 && cp <= 0x3FFFD)    // CJK Ideographs Extension G-H
+  ) return 2;
+
+  return 1;
+}
+
+// Reused grapheme segmenter — instantiating per-call would be wasteful for
+// strings hit on every render. Default locale is fine; we only care about
+// boundaries, not script-aware ordering.
+const _graphemeSegmenter = (typeof Intl !== 'undefined' && Intl.Segmenter)
+  ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+  : null;
+
+/**
+ * Get the visible width of a string in terminal columns, excluding ANSI
+ * codes and counting wide characters (CJK ideographs, emoji, fullwidth)
+ * as 2 columns. Combining marks, variation selectors, and ZWJ are 0-width.
+ * Grapheme clusters that contain at least one wide code point clamp to 2
+ * — so a ZWJ family (e.g. 👨‍👩‍👧, which is 5 code points = 13 UTF-16 units)
+ * counts as 2, matching how terminals render it.
+ *
+ * Without this, branch names with emoji/CJK misalign sparklines, badges
+ * and box borders because the renderer's `padRight`/truncation math drifts
+ * by one or more columns per non-ASCII character.
+ *
+ * @param {string} str - String potentially containing ANSI codes and unicode
+ * @returns {number} Visible width in terminal columns
  */
 function visibleLength(str) {
-  return stripAnsi(str).length;
+  const stripped = stripAnsi(str);
+  // ASCII fast path — every char is 1 column, regex avoids the Segmenter
+  // setup cost on the renderer's hot path.
+  if (/^[\x20-\x7e]*$/.test(stripped)) return stripped.length;
+  if (!_graphemeSegmenter) {
+    // Pre-Intl.Segmenter fallback (shouldn't hit on Node 16+).
+    let width = 0;
+    for (const ch of stripped) width += _codePointWidth(ch.codePointAt(0));
+    return width;
+  }
+  let total = 0;
+  for (const { segment } of _graphemeSegmenter.segment(stripped)) {
+    let clusterTotal = 0;
+    let clusterHasWide = false;
+    for (const ch of segment) {
+      const w = _codePointWidth(ch.codePointAt(0));
+      if (w === 2) clusterHasWide = true;
+      clusterTotal += w;
+    }
+    // ZWJ-joined emoji clusters (e.g. family / flag / skin-tone) sum to
+    // more than 2 by code point, but render as a single 2-column glyph.
+    // Cap them at 2; non-wide clusters (combining marks on a base char)
+    // still take at least 1 column.
+    total += clusterHasWide ? 2 : Math.max(1, clusterTotal);
+  }
+  return total;
 }
 
 /**
@@ -382,14 +476,39 @@ function truncate(str, maxLen, suffix = '…') {
   // raw input with cursor/screen-control sequences in it. SGR survives.
   const safeStr = sanitizeForRender(str);
   const visible = stripAnsi(safeStr);
-  if (visible.length <= maxLen) {
+
+  // Compare in display columns, not UTF-16 code units, so a string of CJK
+  // ideographs (e.g. "中文测试" — 4 code units, 8 columns) is correctly
+  // recognised as needing truncation in a 4-column slot.
+  if (visibleLength(visible) <= maxLen) {
     return safeStr;
   }
 
-  // Long-string path: drop ALL escapes (including SGR), truncate, append
-  // ellipsis + reset. Existing behaviour, kept for layout determinism.
-  const truncated = visible.slice(0, maxLen - suffix.length);
-  return truncated + suffix + ansi.reset;
+  // Long-string path: drop ALL escapes (including SGR), accumulate
+  // graphemes up to the column budget, append ellipsis + reset. Walking
+  // graphemes (not code units) keeps wide characters from being split
+  // mid-glyph and keeps the truncated width <= maxLen even for emoji
+  // and CJK input.
+  const suffixWidth = visibleLength(suffix);
+  const budget = Math.max(0, maxLen - suffixWidth);
+  let acc = '';
+  let used = 0;
+  if (_graphemeSegmenter) {
+    for (const { segment } of _graphemeSegmenter.segment(visible)) {
+      const w = visibleLength(segment);
+      if (used + w > budget) break;
+      acc += segment;
+      used += w;
+    }
+  } else {
+    for (const ch of visible) {
+      const w = _codePointWidth(ch.codePointAt(0));
+      if (used + w > budget) break;
+      acc += ch;
+      used += w;
+    }
+  }
+  return acc + suffix + ansi.reset;
 }
 
 /**