@indigoai-us/hq-cloud 6.18.19 → 6.18.20-alpha.732c

package/dist/watcher.js

@@ -356,8 +356,9 @@ function errorPath(err) {
  * Which backend a platform gets.
  *
  *   - macOS (FSEvents) and Windows (ReadDirectoryChangesW) watch a directory
- *     recursively with ONE OS handle, so the scoped planner places a few
- *     recursive watches over the in-scope tree.
+ *     recursively with ONE OS handle. Windows uses the exact scoped plan;
+ *     macOS uses a depth-bounded plan to keep its shared FSEvents stream's
+ *     registered path set small while the event filter preserves upload scope.
  *   - Linux has no recursive handle: a directory watch reports only its own
  *     direct contents. The same scoped backend runs with one shallow inotify
  *     watch per in-scope directory instead — and NONE per file, because the
@@ -370,7 +371,9 @@ function errorPath(err) {
 export function selectTreeWatchBackend(platform, forcePolling) {
     if (forcePolling)
         return "polling";
-    if (platform === "darwin" || platform === "win32")
+    if (platform === "darwin")
+        return "native-coarse";
+    if (platform === "win32")
         return "native-recursive";
     if (platform === "linux")
         return "native-shallow";
@@ -390,6 +393,12 @@ function startChokidarTreeWatch(hqRoot, shouldEmit, onEvent, onError, maxWatched
     const readyListeners = new Set();
     try {
         cw = watch(hqRoot, {
+            // Push walkers record a directory symlink as a link entry and never
+            // traverse its target. Keep polling discovery on the same boundary so
+            // aliased trees do not consume the path budget or produce events for
+            // content that cannot upload. Chokidar still reports changes to the
+            // symlink entry itself.
+            followSymlinks: false,
             // On Linux chokidar adds one fs.watch/inotify watch per descended dir.
             // The predicate therefore enforces both scope and the hard per-runner cap.
             ignored: toChokidarIgnored(shouldEmit, hqRoot, budget),
@@ -642,7 +651,7 @@ export function startScopedRecursiveWatch(hqRoot, shouldEmit, onEvent, onError,
         const openedOn = directoryIdentity(dir);
         let handle;
         try {
-            handle = fs.watch(dir, { recursive, persistent: true }, (eventType, filename) => {
+            handle = (opts.watchDirectory ?? fs.watch)(dir, { recursive, persistent: true }, (eventType, filename) => {
                 // `filename` is relative to THIS watch's directory (or null/empty if
                 // the platform couldn't provide it — nothing actionable then).
                 // `String()` coerces both the string and (older @types/node) Buffer
@@ -680,6 +689,11 @@ export function startScopedRecursiveWatch(hqRoot, shouldEmit, onEvent, onError,
         }
         handle.on("error", (err) => {
             onError(err);
+            // TreeWatcher handles systemic watch exhaustion by closing this backend
+            // and moving to polling. Reopening the failed path before that transition
+            // runs only repeats the same EMFILE/ENFILE failure.
+            if (isSystemicWatchError(err))
+                return;
             // A handle a re-plan already replaced (retiring) must not tear down its
             // replacement at the same path.
             if (closed || watchers.get(dir) !== handle)
@@ -730,6 +744,7 @@ export function startScopedRecursiveWatch(hqRoot, shouldEmit, onEvent, onError,
                 }
                 : onDirectorySeen,
             recursiveWatches,
+            maxDepth: opts.maxDepth,
             listChildDirs: opts.listChildDirs,
         }));
     }
@@ -1002,13 +1017,39 @@ export function startScopedRecursiveWatch(hqRoot, shouldEmit, onEvent, onError,
  * ancestor-descent pruning that the chokidar backend needs
  * {@link toChokidarIgnored} to avoid.
  */
-function startTreeWatch(hqRoot, shouldEmit, onEvent, onError, maxWatchedPaths, onWatchBudgetExceeded, onDirectorySeen, forcePolling = false) {
+/** @internal Exported for backend-level regression tests. */
+export function startTreeWatch(hqRoot, shouldEmit, onEvent, onError, maxWatchedPaths, onWatchBudgetExceeded, onDirectorySeen, forcePolling = false) {
+    // Resolve the root once before the backend starts. Chokidar with
+    // followSymlinks:false treats descendant links as leaf entries, but an
+    // explicitly supplied root may itself be a symlink. Watch its real tree and
+    // map observed paths back to the caller's root spelling so the caller's
+    // filter and path routing retain their existing contract.
+    const displayRoot = path.resolve(hqRoot);
+    const root = fs.realpathSync(displayRoot);
+    const displayPath = (absolutePath) => root === displayRoot
+        ? absolutePath
+        : path.join(displayRoot, path.relative(root, absolutePath));
+    const watchFilter = root === displayRoot
+        ? shouldEmit
+        : (absolutePath, isDir) => shouldEmit(displayPath(absolutePath), isDir);
+    const watchEvent = root === displayRoot
+        ? onEvent
+        : (absolutePath, kind) => onEvent(displayPath(absolutePath), kind);
+    const watchDirectorySeen = onDirectorySeen
+        ? root === displayRoot
+            ? onDirectorySeen
+            : (absolutePath) => onDirectorySeen(displayPath(absolutePath))
+        : undefined;
     const choice = selectTreeWatchBackend(process.platform, forcePolling);
-    if (choice === "native-recursive" || choice === "native-shallow") {
+    if (choice === "native-recursive" ||
+        choice === "native-coarse" ||
+        choice === "native-shallow") {
         try {
-            const scoped = startScopedRecursiveWatch(hqRoot, shouldEmit, onEvent, onError, onDirectorySeen, choice === "native-shallow"
+            const scoped = startScopedRecursiveWatch(root, watchFilter, watchEvent, onError, watchDirectorySeen, choice === "native-shallow"
                 ? { recursiveWatches: false, maxWatchedPaths, onWatchBudgetExceeded }
-                : {});
+                : choice === "native-coarse"
+                    ? { maxDepth: 2 }
+                    : {});
             // Partial coverage is worse than a different backend: a planned root we
             // could not attach is silently unwatched forever, and the operator only
             // sees it as "instant sync stopped working for that subtree". Accept the
@@ -1024,7 +1065,7 @@ function startTreeWatch(hqRoot, shouldEmit, onEvent, onError, maxWatchedPaths, o
             onError(err);
         }
     }
-    return startChokidarTreeWatch(hqRoot, shouldEmit, onEvent, onError, maxWatchedPaths, onWatchBudgetExceeded, forcePolling);
+    return startChokidarTreeWatch(root, watchFilter, watchEvent, onError, maxWatchedPaths, onWatchBudgetExceeded, forcePolling);
 }
 /**
  * Build the composite emit-decision predicate. Returns true when a change to