fix(graph): auto-reconnect file watcher when daemon closes

When the daemon restarts (e.g., due to lock file or version changes),
the graph command's file watcher connection is closed. Instead of
exiting, the watcher now attempts to reconnect with exponential backoff
and automatically re-registers itself with the new daemon.

This ensures that the graph watch mode continues working seamlessly
through daemon restarts without user intervention.

Author: FrozenPandaz

packages/nx/src/command-line/graph/graph.ts

@@ -807,57 +807,146 @@ function debounce(fn: (...args) => void, time: number) {
   };
 }
 
+const WATCHER_RECONNECT_CONFIG = {
+  initialDelayMs: 100,
+  maxDelayMs: 5000,
+  backoffMultiplier: 1.5,
+  maxAttempts: 30,
+};
+
+async function waitForWatcherReconnectWithExponentialBackoff(
+  config = WATCHER_RECONNECT_CONFIG
+): Promise<boolean> {
+  let delay = config.initialDelayMs;
+  let attempts = 0;
+
+  while (attempts < config.maxAttempts) {
+    try {
+      // Try to register file watcher
+      const testUnregister = await daemonClient.registerFileWatcher(
+        {
+          watchProjects: 'all',
+          includeGlobalWorkspaceFiles: true,
+          allowPartialGraph: true,
+        },
+        () => {
+          // This is just a test connection, close it immediately
+        }
+      );
+      testUnregister();
+      return true;
+    } catch (e) {
+      attempts++;
+      if (attempts >= config.maxAttempts) {
+        return false;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay = Math.min(delay * config.backoffMultiplier, config.maxDelayMs);
+    }
+  }
+
+  return false;
+}
+
 function createFileWatcher() {
-  return daemonClient.registerFileWatcher(
-    {
-      watchProjects: 'all',
-      includeGlobalWorkspaceFiles: true,
-      allowPartialGraph: true,
-    },
-    debounce(async (error, changes) => {
-      if (error === 'closed') {
-        output.error({ title: `Watch error: Daemon closed the connection` });
+  let unregisterCurrentWatcher: (() => void) | undefined;
+
+  const watcherCallback = debounce(async (error, changes) => {
+    if (error === 'closed') {
+      output.note({
+        title: `Daemon connection closed. Attempting to reconnect...`,
+      });
+
+      // Try to reconnect with exponential backoff
+      const reconnected = await waitForWatcherReconnectWithExponentialBackoff();
+
+      if (reconnected) {
+        output.note({
+          title: 'Reconnected to daemon. Resuming file watching.',
+        });
+        // Re-register the watcher with the new daemon connection
+        unregisterCurrentWatcher = await daemonClient.registerFileWatcher(
+          {
+            watchProjects: 'all',
+            includeGlobalWorkspaceFiles: true,
+            allowPartialGraph: true,
+          },
+          watcherCallback
+        );
+      } else {
+        output.error({
+          title: `Failed to reconnect to daemon. Stopping file watcher.`,
+        });
         process.exit(1);
-      } else if (error) {
-        output.error({ title: `Watch error: ${error?.message ?? 'Unknown'}` });
-      } else if (changes !== null && changes.changedFiles.length > 0) {
-        output.note({ title: 'Recalculating project graph...' });
-
-        const { projectGraphClientResponse, sourceMapResponse } =
-          await createProjectGraphAndSourceMapClientResponse();
-
-        if (
-          projectGraphClientResponse.hash !==
-            currentProjectGraphClientResponse.hash &&
-          sourceMapResponse
-        ) {
-          if (projectGraphClientResponse.errors?.length > 0) {
-            projectGraphClientResponse.errors.forEach((e) => {
-              output.error({
-                title: e.message,
-                bodyLines: [e.stack],
-              });
-            });
-            output.warn({
-              title: `${
-                projectGraphClientResponse.errors.length > 1
-                  ? `${projectGraphClientResponse.errors.length} errors`
-                  : `An error`
-              } occured while processing the project graph. Showing partial graph.`,
+      }
+    } else if (error) {
+      output.error({ title: `Watch error: ${error?.message ?? 'Unknown'}` });
+    } else if (changes !== null && changes.changedFiles.length > 0) {
+      output.note({ title: 'Recalculating project graph...' });
+
+      const { projectGraphClientResponse, sourceMapResponse } =
+        await createProjectGraphAndSourceMapClientResponse();
+
+      if (
+        projectGraphClientResponse.hash !==
+          currentProjectGraphClientResponse.hash &&
+        sourceMapResponse
+      ) {
+        if (projectGraphClientResponse.errors?.length > 0) {
+          projectGraphClientResponse.errors.forEach((e) => {
+            output.error({
+              title: e.message,
+              bodyLines: [e.stack],
             });
-          }
-          output.note({ title: 'Graph changes updated.' });
+          });
+          output.warn({
+            title: `${
+              projectGraphClientResponse.errors.length > 1
+                ? `${projectGraphClientResponse.errors.length} errors`
+                : `An error`
+            } occured while processing the project graph. Showing partial graph.`,
+          });
+        }
+        output.note({ title: 'Graph changes updated.' });
 
-          currentProjectGraphClientResponse = projectGraphClientResponse;
-          currentSourceMapsClientResponse = sourceMapResponse;
-          // Clear task graph cache when project graph changes
-          clearTaskGraphCache();
+        currentProjectGraphClientResponse = projectGraphClientResponse;
+        currentSourceMapsClientResponse = sourceMapResponse;
+        // Clear task graph cache when project graph changes
+        clearTaskGraphCache();
+      } else {
+        output.note({ title: 'No graph changes found.' });
+      }
+    }
+  }, 500);
+
+  return daemonClient
+    .registerFileWatcher(
+      {
+        watchProjects: 'all',
+        includeGlobalWorkspaceFiles: true,
+        allowPartialGraph: true,
+      },
+      async (error, changes) => {
+        if (error === 'closed') {
+          // Store the unregister callback before attempting reconnection
+          const previousUnregister = unregisterCurrentWatcher;
+          await watcherCallback(error, changes);
+          if (
+            unregisterCurrentWatcher &&
+            unregisterCurrentWatcher !== previousUnregister
+          ) {
+            // Successfully reconnected with a new watcher
+            return;
+          }
         } else {
-          output.note({ title: 'No graph changes found.' });
+          await watcherCallback(error, changes);
         }
       }
-    }, 500)
-  );
+    )
+    .then((unregister) => {
+      unregisterCurrentWatcher = unregister;
+      return unregister;
+    });
 }
 
 async function createProjectGraphAndSourceMapClientResponse(