@mnemonik/scanner 5.131.2 → 5.135.4

package/src/watcher.ts

@@ -1,6 +1,6 @@
 import { watch, type FSWatcher } from 'fs';
 import { join, relative } from 'path';
-import { readdir } from 'fs/promises';
+import { readdir, stat } from 'fs/promises';
 import { isGitBoundary } from '@mnemonik/shared';
 
 const SKIP_DIRS = new Set([
@@ -27,7 +27,15 @@ export type ChangeHandler = (changedFiles: string[]) => void;
 export type ErrorHandler = (err: Error) => void;
 
 export class FileWatcher {
-  private watchers: FSWatcher[] = [];
+  // Keyed by directory so a watcher can be closed and re-attached when the
+  // directory is deleted and recreated at the same path.
+  private watchers = new Map<string, FSWatcher>();
+  private watchedDirs = new Set<string>();
+  // Inode per watched directory: a delete+recreate faster than the delete
+  // event's stat() presents as "directory exists and is already watched",
+  // but the live watcher is bound to the OLD inode and is inert. Comparing
+  // inodes at event time detects the swap so the subtree can re-attach.
+  private watchedDirInodes = new Map<string, number>();
   private pendingFiles = new Set<string>();
   private flushTimer: ReturnType<typeof setTimeout> | null = null;
   private debounceMs: number;
@@ -49,10 +57,12 @@ export class FileWatcher {
   }
 
   stop(): void {
-    for (const w of this.watchers) {
+    for (const w of this.watchers.values()) {
       w.close();
     }
-    this.watchers = [];
+    this.watchers.clear();
+    this.watchedDirs.clear();
+    this.watchedDirInodes.clear();
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
@@ -74,14 +84,29 @@ export class FileWatcher {
   private async watchDir(dir: string): Promise<void> {
     const dirName = dir.split('/').pop() ?? '';
     if (SKIP_DIRS.has(dirName)) return;
+    // Dedup guard — the change callback re-enters watchDir for new
+    // subdirectories, and a rapid create/rename burst can resolve the same
+    // path twice before the first watch is registered.
+    if (this.watchedDirs.has(dir)) return;
+    this.watchedDirs.add(dir);
 
     try {
-      const watcher = watch(dir, { persistent: true }, (_event, filename) => {
+      // Record the inode BEFORE attaching so watchNewDir can distinguish a
+      // benign event on this directory from a recreate-at-same-path.
+      this.watchedDirInodes.set(dir, (await stat(dir)).ino);
+      const watcher = watch(dir, { persistent: true }, (event, filename) => {
         if (!filename) return;
         const fullPath = join(dir, filename);
         const relPath = relative(this.rootPath, fullPath);
         this.pendingFiles.add(relPath);
         this.scheduleFlush();
+        // fs.watch is non-recursive: the initial recursion below only covers
+        // directories that existed at start(). When this event is a newly
+        // created directory, attach a watcher to it too — otherwise the
+        // subtree is a permanent blind spot until restart. Fire-and-forget;
+        // watchNewDir no-ops for plain files, skip dirs, git boundaries, and
+        // already-watched paths.
+        void this.watchNewDir(fullPath, event);
       });
 
       watcher.on('error', (err) => {
@@ -91,7 +116,7 @@ export class FileWatcher {
         }
       });
 
-      this.watchers.push(watcher);
+      this.watchers.set(dir, watcher);
 
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
@@ -104,8 +129,91 @@ export class FileWatcher {
           await this.watchDir(child);
         }
       }
+    } catch (err) {
+      // Watch registration failed. Never fatal for the subtree's parent, but
+      // the *reason* matters: inotify/fd limit exhaustion means silently
+      // growing blind spots, while permission-denied is a benign property of
+      // the directory itself. Drop the bookkeeping (and any watcher that did
+      // attach before the failure) so a later retry can re-enter cleanly.
+      this.watchedDirs.delete(dir);
+      this.watchedDirInodes.delete(dir);
+      const stale = this.watchers.get(dir);
+      if (stale) {
+        stale.close();
+        this.watchers.delete(dir);
+      }
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === 'ENOSPC' || code === 'EMFILE' || code === 'ENFILE') {
+        console.warn(
+          `[scanner] Watch limit reached (${code}) — subtree unwatched: ${dir}. ` +
+            'Raise fs.inotify.max_user_watches or trim scanner roots.'
+        );
+        // Surface to the daemon only for the root — losing the root means the
+        // whole project is blind; a subtree gap must not tear the project down
+        // (the daemon's onError removes the project entirely).
+        if (dir === this.rootPath && this.onError) {
+          this.onError(err as Error);
+        }
+      } else {
+        // Permission denied or inaccessible directory
+        console.warn(`[scanner] Cannot watch ${dir}: ${(err as Error).message}`);
+      }
+    }
+  }
+
+  /**
+   * Attach a watcher to a directory created after start(). Called from the
+   * per-directory change callback with every event path; stats the path and
+   * only recurses when it is a genuinely new, watchable directory.
+   */
+  private async watchNewDir(fullPath: string, eventType: string): Promise<void> {
+    try {
+      // Stat before the dedup check: a delete event arrives with the same
+      // path as the original create, and the stale watchedDirs entry must
+      // not short-circuit the vanish detection below.
+      const s = await stat(fullPath);
+      if (!s.isDirectory()) return;
+      if (this.watchedDirs.has(fullPath)) {
+        // Already watched — but a delete+recreate faster than this stat
+        // presents exactly like this, with the live watcher bound to the
+        // OLD (dead) inode and inert. A 'rename' event means the entry's
+        // identity changed (created / deleted / moved), so re-attach
+        // unconditionally — comparing inodes is NOT sufficient there
+        // because ext4 routinely hands the freed inode straight back to
+        // the recreated directory. 'change' events are attrib noise (a
+        // write inside the child bumps its mtime, which fires on the
+        // parent), so the cheap inode check keeps those churn-free.
+        if (eventType !== 'rename' && this.watchedDirInodes.get(fullPath) === s.ino) return;
+        this.unwatchSubtree(fullPath);
+      }
+      if (await isGitBoundary(fullPath)) return;
+      await this.watchDir(fullPath);
     } catch {
-      // Permission denied or inaccessible directory
+      // Path vanished between event and stat. If it (or anything under it)
+      // was a watched directory, drop the bookkeeping and close the dead
+      // watchers — otherwise the dedup guards in watchDir/watchNewDir block
+      // re-attachment forever when the path is recreated (build-output
+      // wipes, codegen, rm -rf && mkdir).
+      this.unwatchSubtree(fullPath);
+    }
+  }
+
+  /**
+   * Forget a deleted directory and everything watched beneath it. fs.watch
+   * emits no per-descendant events on a recursive delete, so the whole
+   * prefix must be purged here for a recreate to re-watch the full subtree.
+   */
+  private unwatchSubtree(root: string): void {
+    const prefix = root + '/';
+    for (const dir of this.watchedDirs) {
+      if (dir !== root && !dir.startsWith(prefix)) continue;
+      this.watchedDirs.delete(dir);
+      this.watchedDirInodes.delete(dir);
+      const w = this.watchers.get(dir);
+      if (w) {
+        w.close();
+        this.watchers.delete(dir);
+      }
     }
   }
 }