git-watchtower 1.14.8 → 1.14.10

package/bin/git-watchtower.js

@@ -748,42 +748,63 @@ function startServerProcess() {
   }
 }
 
+/**
+ * Stop the user's dev-server child process and its entire process group.
+ *
+ * Returns a Promise that resolves when the process has actually exited (or a
+ * hard cap elapses). Callers on async exit paths — shutdown(), uncaughtException,
+ * unhandledRejection — must await this so the SIGKILL escalation timer fires
+ * before process.exit() drops it. Synchronous callers (startServerProcess's
+ * restart branch, the 'exit' fallback) can fire-and-forget; best effort only.
+ */
 function stopServerProcess() {
-  if (!serverProcess) return;
+  if (!serverProcess) return Promise.resolve();
 
   addLog('Stopping server...', 'update');
 
   // Capture reference before nulling — needed for deferred SIGKILL
   const proc = serverProcess;
+  serverProcess = null;
+  store.setState({ serverRunning: false });
+
+  // Resolves when the child actually exits
+  const closedPromise = proc.exitCode !== null
+    ? Promise.resolve()
+    : new Promise((resolve) => { proc.once('close', () => resolve()); });
+
+  // Hard cap so callers can never hang forever if 'close' never fires
+  // (e.g. stdio pipe torn down, handle state corrupted). Grace period plus
+  // a small buffer for SIGKILL delivery + OS reap of the process group.
+  const hardCap = new Promise((resolve) => setTimeout(resolve, FORCE_KILL_GRACE_MS + 500));
 
-  // Try graceful shutdown first
   if (process.platform === 'win32') {
+    // taskkill /f /t is already forceful and recursive; close should follow shortly
     spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t']);
-  } else {
-    // Kill the entire process group (negative PID) so that
-    // grandchildren (e.g. npm -> node -> vite) are also terminated.
+    return Promise.race([closedPromise, hardCap]);
+  }
+
+  // Kill the entire process group (negative PID) so that grandchildren
+  // (e.g. npm -> node -> vite) are also terminated.
+  try {
+    process.kill(-proc.pid, 'SIGTERM');
+  } catch (e) {
+    // Process group may already be dead
+  }
+  // Force kill after grace period if process hasn't exited
+  const forceKillTimeout = setTimeout(() => {
     try {
-      process.kill(-proc.pid, 'SIGTERM');
+      process.kill(-proc.pid, 'SIGKILL');
     } catch (e) {
       // Process group may already be dead
     }
-    // Force kill after grace period if process hasn't exited
-    const forceKillTimeout = setTimeout(() => {
-      try {
-        process.kill(-proc.pid, 'SIGKILL');
-      } catch (e) {
-        // Process group may already be dead
-      }
-    }, FORCE_KILL_GRACE_MS);
+  }, FORCE_KILL_GRACE_MS);
 
-    // Clear the force-kill timer if the process exits cleanly
-    proc.once('close', () => {
-      clearTimeout(forceKillTimeout);
-    });
-  }
+  // Clear the force-kill timer if the process exits cleanly
+  proc.once('close', () => {
+    clearTimeout(forceKillTimeout);
+  });
 
-  serverProcess = null;
-  store.setState({ serverRunning: false });
+  return Promise.race([closedPromise, hardCap]);
 }
 
 function restartServerProcess() {
@@ -3472,11 +3493,16 @@ let monitorLockFile = null;
  * times and from any exit path (shutdown, uncaughtException, 'exit').
  *
  * Every step is wrapped in try/catch so a failure in one resource does
- * not prevent the rest from being cleaned up. Stays synchronous so it
- * can run inside an 'exit' handler where async callbacks won't execute.
+ * not prevent the rest from being cleaned up. The body is synchronous
+ * so it still runs inside an 'exit' handler where async callbacks won't
+ * execute; the dev-server close promise is bubbled up so async callers
+ * can await it before process.exit().
+ *
+ * @returns {Promise<void>} resolves when the dev-server child has exited
+ *   (or a hard cap elapses). Synchronous callers may ignore it.
  */
 function cleanupResources() {
-  if (_resourcesCleaned) return;
+  if (_resourcesCleaned) return Promise.resolve();
   _resourcesCleaned = true;
 
   // Restore terminal first so the user sees a clean prompt even if a
@@ -3511,9 +3537,14 @@ function cleanupResources() {
     } catch (_) { /* clients set may have mutated mid-iteration during shutdown */ }
   }
 
-  // User's dev-server process (command mode)
+  // User's dev-server process (command mode). Capture the close promise so
+  // async callers (shutdown/uncaughtException/unhandledRejection) can await
+  // it before process.exit() — otherwise the SIGKILL escalation timer gets
+  // dropped and a dev server that ignored SIGTERM survives as a detached
+  // orphan (it was spawned in its own process group on Unix).
+  let serverStopPromise = Promise.resolve();
   if (SERVER_MODE === 'command') {
-    try { stopServerProcess(); } catch (_) { /* dev-server child may already be gone */ }
+    try { serverStopPromise = stopServerProcess(); } catch (_) { /* dev-server child may already be gone */ }
   }
 
   // Web dashboard + worker/coordinator (unlinks lock file + IPC socket)
@@ -3525,13 +3556,15 @@ function cleanupResources() {
     try { monitorLock.release(monitorLockFile); } catch (_) { /* lock file may have been unlinked externally */ }
     monitorLockFile = null;
   }
+
+  return serverStopPromise;
 }
 
 async function shutdown() {
   if (isShuttingDown) return;
   isShuttingDown = true;
 
-  cleanupResources();
+  const serverStopPromise = cleanupResources();
 
   // For the static HTTP server, give in-flight connections a brief
   // grace period to drain. cleanupResources ended the SSE clients; this
@@ -3543,6 +3576,12 @@ async function shutdown() {
     await Promise.race([serverClosePromise, timeoutPromise]);
   }
 
+  // Wait for the user's dev-server child to actually exit (SIGTERM +
+  // FORCE_KILL_GRACE_MS SIGKILL escalation inside stopServerProcess).
+  // Without this the escalation timer gets dropped by process.exit() below
+  // and a dev server that ignored SIGTERM survives as a detached orphan.
+  try { await serverStopPromise; } catch (_) { /* best-effort */ }
+
   // Flush telemetry
   telemetry.capture('session_ended', {
     duration_seconds: sessionStartTime ? Math.round((Date.now() - sessionStartTime) / 1000) : 0,
@@ -3569,11 +3608,14 @@ process.on('uncaughtException', async (err) => {
   // Synchronous teardown first — so the coordinator socket, lock file,
   // dev-server child process group, and SSE clients are released even
   // if telemetry shutdown hangs or throws.
-  cleanupResources();
+  const serverStopPromise = cleanupResources();
 
   try { telemetry.captureError(err); } catch (_) { /* telemetry must never prevent crash cleanup */ }
   console.error('Uncaught exception:', err);
   try { await telemetry.shutdown(); } catch (_) { /* telemetry must never prevent crash cleanup */ }
+  // Wait for the dev-server SIGKILL escalation before exiting — otherwise
+  // process.exit() drops the pending timer and a stuck server orphans.
+  try { await serverStopPromise; } catch (_) { /* best-effort */ }
   process.exit(1);
 });
 
@@ -3585,12 +3627,15 @@ process.on('uncaughtException', async (err) => {
 process.on('unhandledRejection', async (reason) => {
   isShuttingDown = true;
 
-  cleanupResources();
+  const serverStopPromise = cleanupResources();
 
   const err = reason instanceof Error ? reason : new Error(String(reason));
   try { telemetry.captureError(err); } catch (_) { /* telemetry must never prevent crash cleanup */ }
   console.error('Unhandled rejection:', reason);
   try { await telemetry.shutdown(); } catch (_) { /* telemetry must never prevent crash cleanup */ }
+  // Wait for the dev-server SIGKILL escalation before exiting — otherwise
+  // process.exit() drops the pending timer and a stuck server orphans.
+  try { await serverStopPromise; } catch (_) { /* best-effort */ }
   process.exit(1);
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.14.8",
+  "version": "1.14.10",
   "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

@@ -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;
     }
   }