@indigoai-us/hq-cloud 6.18.21 → 6.18.22-alpha.732d

package/dist/watcher.test.js

@@ -1,11 +1,12 @@
 import { afterEach, beforeEach, describe, it, expect, vi } from "vitest";
+import { EventEmitter } from "node:events";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import { createHash } from "node:crypto";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import { watch } from "chokidar";
-import { FakeClock, WatchPushDriver, TreeWatcher, ChokidarWatchBudget, createWatchPathFilter, toChokidarIgnored, PushEventEmitter, PUBLISH_OUTCOME_JOURNALD_CEILING_BYTES, PUBLISH_OUTCOME_SUCCESS_SAMPLE_CAP, resolveEventDebounceConfig, summarizePublishBatchOutcome, DEFAULT_EVENT_DEBOUNCE_MS, DEFAULT_EVENT_MAX_WAIT_MS, DEFAULT_EVENT_SMALL_BATCH_DEBOUNCE_MS, DEFAULT_EVENT_SMALL_BATCH_MAX_PATHS, DEFAULT_EVENT_SMALL_BATCH_MAX_BYTES, DEFAULT_PUBLISH_MIN_INTERVAL_MS, EVENT_DEBOUNCE_MS_ENV, EVENT_MAX_WAIT_MS_ENV, EVENT_SMALL_BATCH_DEBOUNCE_MS_ENV, EVENT_SMALL_BATCH_MAX_PATHS_ENV, EVENT_SMALL_BATCH_MAX_BYTES_ENV, DEFAULT_TREE_WATCHER_MAX_WATCHED_PATHS, MAX_TREE_WATCHER_MAX_WATCHED_PATHS, TREE_WATCHER_MAX_WATCHED_PATHS_ENV, resolveMaxWatchedPaths, PUBLISH_MIN_INTERVAL_MS_ENV, resolvePublishMinIntervalMs, DurablePublishedContentHashes, DURABLE_PUBLISHED_HASH_BATCH_FLUSH_MS, replayDurablePublishedContentHashRecordsForTest, startScopedRecursiveWatch, selectTreeWatchBackend } from "./watcher.js";
+import { FakeClock, WatchPushDriver, TreeWatcher, ChokidarWatchBudget, createWatchPathFilter, toChokidarIgnored, PushEventEmitter, PUBLISH_OUTCOME_JOURNALD_CEILING_BYTES, PUBLISH_OUTCOME_SUCCESS_SAMPLE_CAP, resolveEventDebounceConfig, summarizePublishBatchOutcome, DEFAULT_EVENT_DEBOUNCE_MS, DEFAULT_EVENT_MAX_WAIT_MS, DEFAULT_EVENT_SMALL_BATCH_DEBOUNCE_MS, DEFAULT_EVENT_SMALL_BATCH_MAX_PATHS, DEFAULT_EVENT_SMALL_BATCH_MAX_BYTES, DEFAULT_PUBLISH_MIN_INTERVAL_MS, EVENT_DEBOUNCE_MS_ENV, EVENT_MAX_WAIT_MS_ENV, EVENT_SMALL_BATCH_DEBOUNCE_MS_ENV, EVENT_SMALL_BATCH_MAX_PATHS_ENV, EVENT_SMALL_BATCH_MAX_BYTES_ENV, DEFAULT_TREE_WATCHER_MAX_WATCHED_PATHS, MAX_TREE_WATCHER_MAX_WATCHED_PATHS, TREE_WATCHER_MAX_WATCHED_PATHS_ENV, resolveMaxWatchedPaths, PUBLISH_MIN_INTERVAL_MS_ENV, resolvePublishMinIntervalMs, DurablePublishedContentHashes, DURABLE_PUBLISHED_HASH_BATCH_FLUSH_MS, replayDurablePublishedContentHashRecordsForTest, startScopedRecursiveWatch, startNativeRootWatch, startTreeWatch, selectTreeWatchBackend } from "./watcher.js";
 import { StateStore, StateStoreLockError } from "./sync/state-store.js";
 import { HttpPushTransport, PushScopeForbiddenError, RealtimeUnavailableError, } from "./sync/push-transport.js";
 import { computePersonalVaultPaths } from "./personal-vault.js";
@@ -19,6 +20,46 @@ import { computePersonalVaultPaths } from "./personal-vault.js";
  * serve as regression guards for the contract those stories depend on.
  */
 const DEBOUNCE = 2000;
+describe("scoped watcher resource errors", () => {
+    let root;
+    beforeEach(() => {
+        root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "watch-resource-error-")));
+    });
+    afterEach(() => {
+        fs.rmSync(root, { recursive: true, force: true });
+    });
+    it("does not reopen a directory watch after EMFILE", () => {
+        const docs = path.join(root, "docs");
+        fs.mkdirSync(docs);
+        class FakeWatcher extends EventEmitter {
+            close() {
+                this.emit("close");
+                return this;
+            }
+        }
+        const handles = new Map();
+        const watchedPaths = [];
+        const backend = startScopedRecursiveWatch(root, createWatchPathFilter(root, false), () => { }, () => { }, undefined, {
+            recursiveWatches: false,
+            listChildDirs: (dir) => dir === root ? [docs] : [],
+            watchDirectory: (dir) => {
+                const watchPath = dir.toString();
+                watchedPaths.push(watchPath);
+                const handle = new FakeWatcher();
+                handles.set(watchPath, handle);
+                return handle;
+            },
+        });
+        try {
+            expect(watchedPaths.filter((dir) => dir === docs)).toHaveLength(1);
+            handles.get(docs).emit("error", Object.assign(new Error("too many open files"), { code: "EMFILE" }));
+            expect(watchedPaths.filter((dir) => dir === docs)).toHaveLength(1);
+        }
+        finally {
+            backend.close();
+        }
+    });
+});
 function publishedHashRecords(count) {
     const maxPaths = Math.max(1, Math.floor(count / 2));
     let seed = 0x14c0ffee;
@@ -954,6 +995,92 @@ describe("US-002: chokidar descent scope", () => {
         }
     });
 });
+describe("chokidar polling symlink boundaries", () => {
+    async function waitFor(check) {
+        const deadline = Date.now() + 6000;
+        while (Date.now() < deadline) {
+            if (check())
+                return;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        expect(check()).toBe(true);
+    }
+    async function waitReady(backend) {
+        await new Promise((resolve, reject) => {
+            if (!backend.onReady)
+                return resolve();
+            const timer = setTimeout(() => reject(new Error("watcher did not become ready")), 6000);
+            backend.onReady(() => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    it("polls ordinary paths without descending or budgeting symlink targets, while reporting the link entry", async () => {
+        const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "watch-poll-link-root-")));
+        const external = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "watch-poll-link-target-")));
+        const link = path.join(root, ".agents");
+        const events = [];
+        const budgetExceeded = vi.fn();
+        const errors = [];
+        try {
+            fs.mkdirSync(path.join(external, "many", "nested", "directories", "under", "the", "alias"), { recursive: true });
+            fs.mkdirSync(path.join(root, ".codex"), { recursive: true });
+            fs.writeFileSync(path.join(root, ".codex", "config.toml"), "model = 'test'\n");
+            fs.mkdirSync(path.join(root, "workspace", "agency", "scratch"), { recursive: true });
+            fs.writeFileSync(path.join(root, "workspace", "agency", "scratch", "notes.md"), "notes\n");
+            fs.symlinkSync(external, link, "dir");
+            const filter = createWatchPathFilter(root, true);
+            expect(filter(path.join(root, ".codex", "config.toml"))).toBe(true);
+            expect(filter(path.join(root, "workspace", "agency", "scratch", "notes.md"))).toBe(true);
+            const backend = startTreeWatch(root, filter, (absolutePath, kind) => events.push({ path: absolutePath, kind }), (error) => errors.push(error), 7, budgetExceeded, undefined, true);
+            try {
+                await waitReady(backend);
+                expect(backend.mode).toBe("polling");
+                // Root + .codex + workspace/agency/scratch; the link target costs no watches.
+                expect(backend.watchedPathCount()).toBe(5);
+                expect(budgetExceeded).not.toHaveBeenCalled();
+                expect(errors).toEqual([]);
+                fs.unlinkSync(link);
+                await waitFor(() => events.some((event) => event.path === link && event.kind === "unlink"));
+                fs.symlinkSync(external, link, "dir");
+                await waitFor(() => events.some((event) => event.path === link && event.kind === "add"));
+                expect(backend.watchedPathCount()).toBe(5);
+            }
+            finally {
+                backend.close();
+            }
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+            fs.rmSync(external, { recursive: true, force: true });
+        }
+    });
+    it("continues watching when the supplied HQ root is itself a symlink", async () => {
+        const realRoot = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "watch-poll-real-root-")));
+        const parent = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "watch-poll-root-link-")));
+        const linkedRoot = path.join(parent, "hq");
+        const events = [];
+        const errors = [];
+        fs.mkdirSync(path.join(realRoot, "workspace", "agency", "scratch"), { recursive: true });
+        fs.symlinkSync(realRoot, linkedRoot, "dir");
+        const filter = createWatchPathFilter(linkedRoot, true);
+        const backend = startTreeWatch(linkedRoot, filter, (absolutePath) => events.push(absolutePath), (error) => errors.push(error), 20, () => { }, undefined, true);
+        try {
+            await waitReady(backend);
+            const file = path.join(linkedRoot, "workspace", "agency", "scratch", "after-ready.md");
+            fs.writeFileSync(file, "observed\n");
+            await waitFor(() => events.includes(file));
+            expect(errors).toEqual([]);
+        }
+        finally {
+            backend.close();
+            fs.rmSync(linkedRoot, { recursive: true, force: true });
+            fs.rmSync(parent, { recursive: true, force: true });
+            fs.rmSync(realRoot, { recursive: true, force: true });
+        }
+    });
+});
 describe("US-002: TreeWatcher — debounce coalesce (FakeClock seam)", () => {
     function makeWatcher(opts) {
         const clock = new FakeClock();
@@ -4018,14 +4145,85 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
             backend.close();
         }
     });
-    it("selects the folder-only native backend on linux and leaves darwin/win32 on recursive native", () => {
+    it("selects the single-root backend on darwin and leaves linux and windows unchanged", () => {
         expect(selectTreeWatchBackend("linux", false)).toBe("native-shallow");
-        expect(selectTreeWatchBackend("darwin", false)).toBe("native-recursive");
+        expect(selectTreeWatchBackend("darwin", false)).toBe("native-root");
         expect(selectTreeWatchBackend("win32", false)).toBe("native-recursive");
         expect(selectTreeWatchBackend("freebsd", false)).toBe("chokidar");
         expect(selectTreeWatchBackend("linux", true)).toBe("polling");
         expect(selectTreeWatchBackend("darwin", true)).toBe("polling");
     });
+    it("filters native-root callbacks before forwarding them to onEvent", () => {
+        const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "native-root-filter-")));
+        const excludedDir = path.join(dir, "node_modules");
+        fs.mkdirSync(path.join(excludedDir, "pkg"), { recursive: true });
+        fs.writeFileSync(path.join(excludedDir, "pkg", "index.js"), "x");
+        const callback = vi.fn();
+        const handle = new EventEmitter();
+        handle.close = vi.fn();
+        let listener;
+        const backend = startNativeRootWatch(dir, createWatchPathFilter(dir, false), callback, vi.fn(), {
+            watchDirectory: ((root, options, onChange) => {
+                expect(root).toBe(dir);
+                expect(options).toEqual({ recursive: true, persistent: true });
+                listener = onChange;
+                return handle;
+            }),
+        });
+        try {
+            expect(backend.mode).toBe("native-root");
+            expect(backend.watchedPathCount()).toBe(1);
+            listener?.("rename", "companies/indigo/knowledge/note.md");
+            listener?.("rename", "node_modules");
+            listener?.("change", "workspace/node_modules/pkg/index.js");
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith(path.join(dir, "companies/indigo/knowledge/note.md"), "rename");
+        }
+        finally {
+            backend.close();
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("switches a native-root watcher to polling after a systemic watch error", async () => {
+        const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "native-root-fallback-")));
+        const closed = [];
+        const backend = new TreeWatcher({
+            hqRoot: dir,
+            debounceMs: 50,
+            backendFactory: ({ forcePolling, onError }) => {
+                if (forcePolling) {
+                    return {
+                        close: () => closed.push("polling"),
+                        mode: "polling",
+                        needsKnownKinds: false,
+                        watchedPathCount: () => 1,
+                    };
+                }
+                const handle = new EventEmitter();
+                handle.close = vi.fn(() => closed.push("native-root"));
+                const native = startNativeRootWatch(dir, () => true, vi.fn(), onError, {
+                    watchDirectory: (() => {
+                        queueMicrotask(() => handle.emit("error", Object.assign(new Error("too many open files"), { code: "EMFILE" })));
+                        return handle;
+                    }),
+                });
+                return native;
+            },
+        });
+        const log = vi.spyOn(console, "error").mockImplementation(() => { });
+        backend.start();
+        try {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(backend.watchMode()).toBe("polling");
+            expect(backend.watchedPathCount()).toBe(1);
+            expect(closed).toContain("native-root");
+        }
+        finally {
+            backend.dispose();
+            log.mockRestore();
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
     it("TreeWatcher on linux starts natively with one watch per directory (no chokidar, no file watches)", async () => {
         if (!isLinux)
             return;