feat(watchers): Improve Node watcher robustness: file-level inode tracking, abortable restarts, restart race guards, and untracked-file handling

ts/watchers/watcher.node.ts

@@ -23,6 +23,17 @@ export class NodeWatcher implements IWatcher {
   // fs.watch watches the inode, not the path. If inode changes, we need to restart.
   private watchedInodes: Map<string, bigint> = new Map();
 
+  // File inode tracking - detect when individual files are deleted and recreated
+  // This is critical: editors delete+recreate files, fs.watch watches OLD inode!
+  // See: https://github.com/paulmillr/chokidar/issues/972
+  private fileInodes: Map<string, bigint> = new Map();
+
+  // Abort controllers for pending restart delays - prevents orphan watchers on stop()
+  private restartAbortControllers: Map<string, AbortController> = new Map();
+
+  // Prevent concurrent restarts for the same path (health check + error can race)
+  private restartingPaths: Set<string> = new Set();
+
   // Configuration constants
   private static readonly MAX_RETRIES = 3;
   private static readonly INITIAL_RESTART_DELAY = 1000;
@@ -47,49 +58,90 @@ export class NodeWatcher implements IWatcher {
 
   /**
    * Restart a watcher after an error with exponential backoff
+   * Includes guards against:
+   * - Dual restart race condition (health check + error handler calling simultaneously)
+   * - Orphan watchers when stop() is called during restart delay
    */
   private async restartWatcher(basePath: string, error: Error): Promise<void> {
-    const attempts = (this.restartAttempts.get(basePath) || 0) + 1;
-    this.restartAttempts.set(basePath, attempts);
-
-    console.log(`[smartwatch] Watcher error for ${basePath}: ${error.message}`);
-    console.log(`[smartwatch] Restart attempt ${attempts}/${NodeWatcher.MAX_RETRIES}`);
-
-    if (attempts > NodeWatcher.MAX_RETRIES) {
-      console.error(`[smartwatch] Max retries exceeded for ${basePath}, giving up`);
-      this.safeEmit({
-        type: 'error',
-        path: basePath,
-        error: new Error(`Max restart retries (${NodeWatcher.MAX_RETRIES}) exceeded`)
-      });
+    // Guard: Prevent concurrent restarts for the same path
+    if (this.restartingPaths.has(basePath)) {
+      console.log(`[smartwatch] Restart already in progress for ${basePath}, skipping`);
       return;
     }
-
-    // Close failed watcher
-    const oldWatcher = this.watchers.get(basePath);
-    if (oldWatcher) {
-      try {
-        oldWatcher.close();
-      } catch {
-        // Ignore close errors
-      }
-      this.watchers.delete(basePath);
-    }
-
-    // Exponential backoff
-    const delay = this.restartDelays.get(basePath) || NodeWatcher.INITIAL_RESTART_DELAY;
-    console.log(`[smartwatch] Waiting ${delay}ms before restart...`);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    this.restartDelays.set(basePath, Math.min(delay * 2, NodeWatcher.MAX_RESTART_DELAY));
+    this.restartingPaths.add(basePath);
 
     try {
-      await this.watchPath(basePath, 0);
-      console.log(`[smartwatch] Successfully restarted watcher for ${basePath}`);
-      this.restartDelays.set(basePath, NodeWatcher.INITIAL_RESTART_DELAY);
-      this.restartAttempts.set(basePath, 0);
-    } catch (restartError) {
-      console.error(`[smartwatch] Restart failed for ${basePath}:`, restartError);
-      this.restartWatcher(basePath, restartError as Error); // Recursive retry
+      const attempts = (this.restartAttempts.get(basePath) || 0) + 1;
+      this.restartAttempts.set(basePath, attempts);
+
+      console.log(`[smartwatch] Watcher error for ${basePath}: ${error.message}`);
+      console.log(`[smartwatch] Restart attempt ${attempts}/${NodeWatcher.MAX_RETRIES}`);
+
+      if (attempts > NodeWatcher.MAX_RETRIES) {
+        console.error(`[smartwatch] Max retries exceeded for ${basePath}, giving up`);
+        this.safeEmit({
+          type: 'error',
+          path: basePath,
+          error: new Error(`Max restart retries (${NodeWatcher.MAX_RETRIES}) exceeded`)
+        });
+        return;
+      }
+
+      // Close failed watcher
+      const oldWatcher = this.watchers.get(basePath);
+      if (oldWatcher) {
+        try {
+          oldWatcher.close();
+        } catch {
+          // Ignore close errors
+        }
+        this.watchers.delete(basePath);
+      }
+
+      // Exponential backoff with AbortController (so stop() can cancel)
+      const delay = this.restartDelays.get(basePath) || NodeWatcher.INITIAL_RESTART_DELAY;
+      console.log(`[smartwatch] Waiting ${delay}ms before restart...`);
+
+      const abortController = new AbortController();
+      this.restartAbortControllers.set(basePath, abortController);
+
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const timeout = setTimeout(resolve, delay);
+          abortController.signal.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            reject(new Error('Restart aborted by stop()'));
+          });
+        });
+      } catch (abortError) {
+        console.log(`[smartwatch] Restart aborted for ${basePath}`);
+        return; // stop() was called, don't continue
+      } finally {
+        this.restartAbortControllers.delete(basePath);
+      }
+
+      // Double-check we're still watching after the delay
+      if (!this._isWatching) {
+        console.log(`[smartwatch] Watcher stopped during restart delay, aborting`);
+        return;
+      }
+
+      this.restartDelays.set(basePath, Math.min(delay * 2, NodeWatcher.MAX_RESTART_DELAY));
+
+      try {
+        await this.watchPath(basePath, 0);
+        console.log(`[smartwatch] Successfully restarted watcher for ${basePath}`);
+        this.restartDelays.set(basePath, NodeWatcher.INITIAL_RESTART_DELAY);
+        this.restartAttempts.set(basePath, 0);
+      } catch (restartError) {
+        console.error(`[smartwatch] Restart failed for ${basePath}:`, restartError);
+        // Clear restartingPaths before recursive call
+        this.restartingPaths.delete(basePath);
+        this.restartWatcher(basePath, restartError as Error); // Recursive retry
+        return; // Don't delete from restartingPaths again in finally
+      }
+    } finally {
+      this.restartingPaths.delete(basePath);
     }
   }
 
@@ -209,6 +261,13 @@ export class NodeWatcher implements IWatcher {
     // Stop health check monitoring
     this.stopHealthCheck();
 
+    // Abort all pending restart delays (prevents orphan watchers)
+    for (const [path, controller] of this.restartAbortControllers) {
+      console.log(`[smartwatch] Aborting pending restart for: ${path}`);
+      controller.abort();
+    }
+    this.restartAbortControllers.clear();
+
     // Cancel all pending debounced emits
     for (const timeout of this.pendingEmits.values()) {
       clearTimeout(timeout);
@@ -223,10 +282,12 @@ export class NodeWatcher implements IWatcher {
     this.watchers.clear();
     this.watchedFiles.clear();
 
-    // Clear restart tracking state
+    // Clear all tracking state
     this.restartDelays.clear();
     this.restartAttempts.clear();
     this.watchedInodes.clear();
+    this.fileInodes.clear();
+    this.restartingPaths.clear();
 
     console.log('[smartwatch] Watcher stopped');
   }
@@ -331,6 +392,12 @@ export class NodeWatcher implements IWatcher {
 
   /**
    * Emit the actual file event after debounce
+   *
+   * Handles file inode tracking to detect delete+recreate scenarios:
+   * - fs.watch watches the inode, not the path
+   * - When editors delete+recreate files, the inode changes
+   * - Without inode tracking, events for the new file would be missed
+   * - See: https://github.com/paulmillr/chokidar/issues/972
    */
   private async emitFileEvent(
     fullPath: string,
@@ -350,38 +417,75 @@ export class NodeWatcher implements IWatcher {
             }
           } else {
             const wasWatched = this.watchedFiles.has(fullPath);
+            const currentInode = BigInt(stats.ino);
+            const previousInode = this.fileInodes.get(fullPath);
+
+            // Track file inode for delete+recreate detection
+            this.fileInodes.set(fullPath, currentInode);
             this.watchedFiles.add(fullPath);
-            this.safeEmit({
-              type: wasWatched ? 'change' : 'add',
-              path: fullPath,
-              stats
-            });
+
+            // Check if file was recreated with different inode (delete+recreate scenario)
+            if (wasWatched && previousInode !== undefined && previousInode !== currentInode) {
+              console.log(`[smartwatch] File inode changed (delete+recreate): ${fullPath}`);
+              console.log(`[smartwatch]   Previous inode: ${previousInode}, current: ${currentInode}`);
+              // Emit as 'change' since the file content likely changed
+              this.safeEmit({ type: 'change', path: fullPath, stats });
+            } else {
+              this.safeEmit({
+                type: wasWatched ? 'change' : 'add',
+                path: fullPath,
+                stats
+              });
+            }
           }
         } else {
           // File doesn't exist - it was deleted
           if (this.watchedFiles.has(fullPath)) {
             const wasDir = this.isKnownDirectory(fullPath);
             this.watchedFiles.delete(fullPath);
+            this.fileInodes.delete(fullPath); // Clean up inode tracking
             this.safeEmit({
               type: wasDir ? 'unlinkDir' : 'unlink',
               path: fullPath
             });
+          } else {
+            // Fix #4: File wasn't tracked but was deleted - still emit event
+            // This handles files created after initial scan that we may have missed
+            console.log(`[smartwatch] Untracked file deleted: ${fullPath}`);
+            this.fileInodes.delete(fullPath);
+            this.safeEmit({ type: 'unlink', path: fullPath });
           }
         }
       } else if (eventType === 'change') {
         // File was modified
         if (stats && !stats.isDirectory()) {
           const wasWatched = this.watchedFiles.has(fullPath);
+          const currentInode = BigInt(stats.ino);
+          const previousInode = this.fileInodes.get(fullPath);
+
+          // Track file inode
+          this.fileInodes.set(fullPath, currentInode);
+
           if (!wasWatched) {
             // This is actually an 'add' - file wasn't being watched before
             this.watchedFiles.add(fullPath);
             this.safeEmit({ type: 'add', path: fullPath, stats });
+          } else if (previousInode !== undefined && previousInode !== currentInode) {
+            // Inode changed during 'change' event - file was replaced
+            console.log(`[smartwatch] File replaced (inode change on modify): ${fullPath}`);
+            this.safeEmit({ type: 'change', path: fullPath, stats });
           } else {
             this.safeEmit({ type: 'change', path: fullPath, stats });
           }
         } else if (!stats && this.watchedFiles.has(fullPath)) {
           // File was deleted
           this.watchedFiles.delete(fullPath);
+          this.fileInodes.delete(fullPath);
+          this.safeEmit({ type: 'unlink', path: fullPath });
+        } else if (!stats && !this.watchedFiles.has(fullPath)) {
+          // Fix #4: Untracked file deleted during 'change' event
+          console.log(`[smartwatch] Untracked file deleted (change event): ${fullPath}`);
+          this.fileInodes.delete(fullPath);
           this.safeEmit({ type: 'unlink', path: fullPath });
         }
       }
@@ -421,6 +525,8 @@ export class NodeWatcher implements IWatcher {
           await this.scanDirectory(fullPath, depth + 1);
         } else if (entry.isFile()) {
           this.watchedFiles.add(fullPath);
+          // Track file inode for delete+recreate detection
+          this.fileInodes.set(fullPath, BigInt(stats.ino));
           this.safeEmit({ type: 'add', path: fullPath, stats });
         }
       }