git-watchtower 1.14.9 → 1.14.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.14.9",
+  "version": "1.14.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/coordinator.js

@@ -34,6 +34,18 @@ const WATCHTOWER_DIR = path.join(os.homedir(), '.watchtower');
  */
 const MAX_IPC_BUFFER = 1024 * 1024;
 
+/**
+ * How long a worker waits for a `registered` ACK from the coordinator
+ * after the TCP connection completes and the `register` frame is written.
+ *
+ * The coordinator responds synchronously inside _handleWorkerMessage, so
+ * anything past a couple of seconds indicates the coordinator is wedged,
+ * crashed between accept() and the handler, or rejected the registration
+ * (duplicate ID). Callers treat timeout as a connect failure and either
+ * retry or fall back to reclaiming the coordinator role.
+ */
+const REGISTRATION_ACK_TIMEOUT_MS = 2000;
+
 /**
  * Lock file path
  */
@@ -492,24 +504,73 @@ class Worker {
     this.onCommand = null;
     this._connected = false;
     this._buffer = '';
+    /** @type {((msg: Object) => void) | null} */
+    this._onRegistered = null;
   }
 
   /**
-   * Connect to the coordinator.
+   * Connect to the coordinator and complete the register handshake.
+   *
+   * Resolves only once the coordinator has replied with a matching
+   * `registered` ACK. Without this, the worker would start pushing state
+   * the instant the TCP connection opens, even if the coordinator crashed
+   * or rejected the registration (e.g. duplicate ID, stale socket) before
+   * processing the `register` frame. In that scenario the pushes would
+   * silently disappear until something else forced a reconnect.
+   *
+   * Rejects if the socket errors, the peer closes before ACK, or the ACK
+   * doesn't arrive within REGISTRATION_ACK_TIMEOUT_MS.
+   *
    * @returns {Promise<void>}
    */
   connect() {
     return new Promise((resolve, reject) => {
+      let settled = false;
+      let ackTimer = null;
+
+      const cleanupHandshake = () => {
+        if (ackTimer) {
+          clearTimeout(ackTimer);
+          ackTimer = null;
+        }
+        this._onRegistered = null;
+      };
+
+      const settleResolve = () => {
+        if (settled) return;
+        settled = true;
+        cleanupHandshake();
+        resolve();
+      };
+
+      const settleReject = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanupHandshake();
+        this._connected = false;
+        try { if (this.socket) this.socket.destroy(); } catch (_) { /* socket may already be torn down */ }
+        reject(err);
+      };
+
+      // Installed before the register frame is sent so an immediate reply
+      // can't race the assignment.
+      this._onRegistered = (msg) => {
+        if (msg && msg.id === this.id) settleResolve();
+      };
+
       this.socket = net.createConnection(this.socketPath, () => {
         this._connected = true;
-        // Register with coordinator
+        // Register with coordinator. Don't resolve yet — wait for the ACK.
         this._send({
           type: 'register',
           id: this.id,
           projectPath: this.projectPath,
           projectName: this.projectName,
         });
-        resolve();
+        ackTimer = setTimeout(() => {
+          settleReject(new Error('coordinator registration ACK timed out'));
+        }, REGISTRATION_ACK_TIMEOUT_MS);
+        if (ackTimer.unref) ackTimer.unref();
       });
 
       this.socket.on('data', (data) => {
@@ -538,11 +599,12 @@ class Worker {
 
       this.socket.on('error', (err) => {
         this._connected = false;
-        reject(err);
+        settleReject(err);
       });
 
       this.socket.on('close', () => {
         this._connected = false;
+        settleReject(new Error('coordinator socket closed before registration'));
       });
     });
   }
@@ -597,6 +659,10 @@ class Worker {
    * @private
    */
   _handleMessage(msg) {
+    if (msg.type === 'registered' && this._onRegistered) {
+      this._onRegistered(msg);
+      return;
+    }
     if (msg.type === 'command' && this.onCommand) {
       this.onCommand(msg.action, msg.payload);
     }

package/src/server/web.js

@@ -63,6 +63,9 @@ class WebDashboardServer {
     this.pushInterval = null;
     this.lastPushedJson = '';
 
+    /** @type {Set<import('net').Socket>} Raw TCP sockets, tracked so stop() can force-close them */
+    this._sockets = new Set();
+
     // Multi-project support (populated by coordinator)
     /** @type {Map<string, Object>} */
     this.projects = new Map();
@@ -239,6 +242,14 @@ class WebDashboardServer {
         this._handleRequest(req, res);
       });
 
+      // Track raw TCP sockets so stop() can force-destroy lingering
+      // connections (long-lived SSE, paused browsers, proxied clients)
+      // instead of waiting for a full TCP FIN_WAIT2 timeout.
+      this.server.on('connection', (/** @type {import('net').Socket} */ socket) => {
+        this._sockets.add(socket);
+        socket.once('close', () => this._sockets.delete(socket));
+      });
+
       this.server.on('error', (/** @type {Error & {code?: string}} */ err) => {
         if (err.code === 'EADDRINUSE' && retries < MAX_PORT_RETRIES) {
           retries++;
@@ -270,7 +281,7 @@ class WebDashboardServer {
       this.pushInterval = null;
     }
 
-    // Close all SSE connections
+    // End SSE response streams gracefully (sends FIN).
     for (const client of this.clients) {
       try { client.end(); } catch (e) { /* SSE client may already be disconnected */ }
     }
@@ -278,6 +289,16 @@ class WebDashboardServer {
 
     if (this.server) {
       this.server.close();
+
+      // Force-destroy any TCP sockets that didn't close after the
+      // graceful end() above. Without this, a paused browser, a
+      // suspended tab, or a slow proxy can pin server.close() for the
+      // full TCP FIN_WAIT2 timeout (typically 60 s), delaying shutdown.
+      for (const socket of this._sockets) {
+        try { socket.destroy(); } catch (e) { /* ignore */ }
+      }
+      this._sockets.clear();
+
       this.server = null;
     }
   }