@indigoai-us/hq-cloud 6.15.0 → 6.15.2

package/test/e2e/watcher-real-chokidar.test.ts

@@ -1,165 +0,0 @@
-/**
- * REAL-chokidar regression E2E for the event-push watcher scope.
- *
- * Why this exists:
- * The Phase-1 watcher tests (US-001/002/003) all drove an INJECTED stub
- * watcher + FakeClock, so they never exercised real chokidar over a real tree
- * with a real `.hqinclude`. That gap let a CONFIG MISMATCH ship in 5.26.0:
- * the runner created the watcher with `personalMode: true`, whose filter
- * excludes the `companies/` top-level -- but the menubar runs `--companies`,
- * whose sync scope is dominated by `companies/<slug>/knowledge` (etc). Net:
- * the watcher excluded exactly the synced paths, so a local edit never
- * triggered an instant push (it silently fell back to the 10-min poll).
- *
- * This test uses a real temp tree, real chokidar, and real timers to assert:
- *   1. With the FIXED scope (personalMode=false, as `--companies` now passes),
- *      an edit under `companies/<slug>/knowledge/` fires a debounced change.
- *   2. With the BUGGY scope (personalMode=true), the same edit does NOT fire --
- *      pinning the exact regression so it can't silently return.
- */
-
-import { mkdtemp, mkdir, rm, unlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { TreeWatcher } from "../../src/watcher.js";
-
-let hqRoot: string;
-let watcher: TreeWatcher | null = null;
-
-beforeEach(async () => {
-  hqRoot = await mkdtemp(path.join(tmpdir(), "hqcloud-watch-e2e-"));
-  // Minimal HQ-like scope: only companies/<slug>/knowledge/ is in-scope,
-  // mirroring the real HQ `.hqinclude` allow-list shape.
-  await writeFile(path.join(hqRoot, ".hqinclude"), "companies/*/knowledge/\n");
-  await mkdir(path.join(hqRoot, "companies", "acme", "knowledge"), {
-    recursive: true,
-  });
-});
-
-afterEach(async () => {
-  watcher?.dispose();
-  watcher = null;
-  await rm(hqRoot, { recursive: true, force: true });
-});
-
-/** Resolve true if the watcher emits a debounced change within `ms`, else false. */
-function waitForEmit(w: TreeWatcher, ms: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    let settled = false;
-    const off = w.onChange(() => {
-      if (settled) return;
-      settled = true;
-      off();
-      clearTimeout(t);
-      resolve(true);
-    });
-    const t = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      off();
-      resolve(false);
-    }, ms);
-  });
-}
-
-describe("event-push watcher -- real chokidar scope (regression for 5.26.0)", () => {
-  it(
-    "preserves unlink classification and the captured pre-delete revision",
-    async () => {
-      const localPath = path.join(
-        hqRoot,
-        "companies",
-        "acme",
-        "knowledge",
-        "delete-me.md",
-      );
-      await writeFile(localPath, "# synced\n");
-      const capture = vi.fn(() => [
-        {
-          journalSlug: "acme",
-          journalPath: "knowledge/delete-me.md",
-          deleteScopeRoot: "knowledge/delete-me.md",
-          absolutePath: localPath,
-          remoteEtag: "etag-before-delete",
-          localHash: "hash-before-delete",
-          localKind: "file" as const,
-        },
-      ]);
-      watcher = new TreeWatcher({
-        hqRoot,
-        debounceMs: 250,
-        personalMode: false,
-        captureLocalDeleteSnapshots: capture,
-      });
-      watcher.start();
-      await new Promise((r) => setTimeout(r, 600));
-
-      const emitted = new Promise<Parameters<Parameters<TreeWatcher["onChange"]>[0]>[1]>(
-        (resolve) => {
-          const off = watcher!.onChange((_rel, batch) => {
-            off();
-            resolve(batch);
-          });
-        },
-      );
-      await unlink(localPath);
-      const batch = await emitted;
-      const change = batch?.changes?.get(localPath);
-
-      expect(capture).toHaveBeenCalledWith(
-        "companies/acme/knowledge/delete-me.md",
-        "unlink",
-      );
-      expect(change).toMatchObject({
-        kind: "unlink",
-        deleteSnapshots: [
-          expect.objectContaining({
-            remoteEtag: "etag-before-delete",
-            localHash: "hash-before-delete",
-          }),
-        ],
-      });
-    },
-    8000,
-  );
-
-  it(
-    "FIRES on a companies/<slug>/knowledge/ edit when personalMode=false (the --companies scope)",
-    async () => {
-      watcher = new TreeWatcher({ hqRoot, debounceMs: 250, personalMode: false });
-      watcher.start();
-      // Let chokidar finish establishing watches before the write.
-      await new Promise((r) => setTimeout(r, 600));
-
-      const emitted = waitForEmit(watcher, 4000);
-      await writeFile(
-        path.join(hqRoot, "companies", "acme", "knowledge", "note.md"),
-        "# hello\n",
-      );
-      expect(await emitted).toBe(true);
-    },
-    8000,
-  );
-
-  it(
-    "does NOT fire on the same edit when personalMode=true (pins the 5.26.0 bug)",
-    async () => {
-      watcher = new TreeWatcher({ hqRoot, debounceMs: 250, personalMode: true });
-      watcher.start();
-      await new Promise((r) => setTimeout(r, 600));
-
-      const emitted = waitForEmit(watcher, 2500);
-      await writeFile(
-        path.join(hqRoot, "companies", "acme", "knowledge", "note2.md"),
-        "# hello\n",
-      );
-      // personalMode excludes the companies/ top-level -> no emit. This is the
-      // bug the fix avoids by passing personalMode=false in --companies mode.
-      expect(await emitted).toBe(false);
-    },
-    8000,
-  );
-});

package/test/e2e/watcher-recursive-backend.test.ts

@@ -1,181 +0,0 @@
-/**
- * REAL-fs regression E2E for the single-recursive-watch backend.
- *
- * Why this exists:
- * chokidar 4 dropped its `fsevents` backend, so on macOS it watches via kqueue
- * — ~1 open fd PER watched path. Over a real HQ tree (~11k files+dirs) that
- * exhausts the default soft `ulimit -n` (256) with EMFILE, silently killing the
- * watcher so instant sync degrades to the 10-min poll. The fix replaces the
- * per-path chokidar watch with a SINGLE recursive `fs.watch` on macOS/Windows
- * (1 OS handle for the whole tree), filtering events per-path at emit time.
- *
- * These tests pin the two load-bearing behaviors of that backend (both also
- * hold for the chokidar Linux fallback, so the suite is backend-agnostic):
- *   1. A file created under a subtree that DID NOT EXIST when the watcher
- *      started still fires — i.e. coverage doesn't depend on per-directory
- *      watch registration at start time.
- *   2. An out-of-scope edit (`repos/`, excluded by DEFAULT_IGNORES) does NOT
- *      fire — the OS reports it under a recursive watch, and it must be dropped
- *      by the emit filter, not woken on.
- */
-
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { TreeWatcher } from "../../src/watcher.js";
-
-let hqRoot: string;
-let watcher: TreeWatcher | null = null;
-
-beforeEach(async () => {
-  hqRoot = await mkdtemp(path.join(tmpdir(), "hqcloud-recwatch-e2e-"));
-  await writeFile(path.join(hqRoot, ".hqinclude"), "companies/*/knowledge/\n");
-  // Only the `acme` company exists at start; `newco` is created later to prove
-  // the recursive watch covers subtrees born after start().
-  await mkdir(path.join(hqRoot, "companies", "acme", "knowledge"), {
-    recursive: true,
-  });
-});
-
-afterEach(async () => {
-  watcher?.dispose();
-  watcher = null;
-  await rm(hqRoot, { recursive: true, force: true });
-});
-
-/** Resolve true if the watcher emits a debounced change within `ms`, else false. */
-function waitForEmit(w: TreeWatcher, ms: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    let settled = false;
-    const off = w.onChange(() => {
-      if (settled) return;
-      settled = true;
-      off();
-      clearTimeout(t);
-      resolve(true);
-    });
-    const t = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      off();
-      resolve(false);
-    }, ms);
-  });
-}
-
-describe("event-push watcher -- single recursive watch backend", () => {
-  it(
-    "preserves unlinkDir classification and tracked descendant snapshots",
-    async () => {
-      const subtree = path.join(
-        hqRoot,
-        "companies",
-        "acme",
-        "knowledge",
-        "moved",
-      );
-      const descendant = path.join(subtree, "one.md");
-      await mkdir(subtree, { recursive: true });
-      await writeFile(descendant, "# one\n");
-      const capture = vi.fn((relativePath: string, kind: string) =>
-        kind === "unlinkDir" && relativePath.endsWith("/moved")
-          ? [
-              {
-                journalSlug: "acme",
-                journalPath: "knowledge/moved/one.md",
-                deleteScopeRoot: "knowledge/moved",
-                absolutePath: descendant,
-                remoteEtag: "etag-one",
-                localHash: "hash-one",
-                localKind: "file" as const,
-              },
-            ]
-          : [],
-      );
-      watcher = new TreeWatcher({
-        hqRoot,
-        debounceMs: 250,
-        personalMode: false,
-        captureLocalDeleteSnapshots: capture,
-      });
-      watcher.start();
-      await new Promise((r) => setTimeout(r, 600));
-
-      const emitted = new Promise<Parameters<Parameters<TreeWatcher["onChange"]>[0]>[1]>(
-        (resolve) => {
-          const off = watcher!.onChange((_rel, batch) => {
-            off();
-            resolve(batch);
-          });
-        },
-      );
-      await rm(subtree, { recursive: true, force: true });
-      const batch = await emitted;
-      const change = batch?.changes?.get(subtree);
-
-      expect(capture).toHaveBeenCalledWith(
-        "companies/acme/knowledge/moved",
-        "unlinkDir",
-      );
-      expect(change).toMatchObject({
-        kind: "unlinkDir",
-        deleteSnapshots: [
-          expect.objectContaining({
-            journalPath: "knowledge/moved/one.md",
-            remoteEtag: "etag-one",
-          }),
-        ],
-      });
-    },
-    8000,
-  );
-
-  it(
-    "FIRES for an in-scope file created under a subtree that did not exist at start",
-    async () => {
-      watcher = new TreeWatcher({ hqRoot, debounceMs: 250, personalMode: false });
-      watcher.start();
-      // Let the recursive watch establish before any mutation.
-      await new Promise((r) => setTimeout(r, 600));
-
-      // Create a brand-new company subtree AFTER the watcher started. A
-      // per-directory watcher would only catch this if it dynamically
-      // registered the new dirs; the recursive watch covers it inherently.
-      await mkdir(path.join(hqRoot, "companies", "newco", "knowledge"), {
-        recursive: true,
-      });
-
-      const emitted = waitForEmit(watcher, 4000);
-      await writeFile(
-        path.join(hqRoot, "companies", "newco", "knowledge", "fresh.md"),
-        "# fresh\n",
-      );
-      expect(await emitted).toBe(true);
-    },
-    8000,
-  );
-
-  it(
-    "does NOT fire for an out-of-scope edit the OS reports under the recursive watch (repos/)",
-    async () => {
-      watcher = new TreeWatcher({ hqRoot, debounceMs: 250, personalMode: false });
-      watcher.start();
-      await new Promise((r) => setTimeout(r, 600));
-
-      // `repos/` is excluded by DEFAULT_IGNORES. Under a recursive OS watch the
-      // event is still delivered, so the emit filter — not watch-time pruning —
-      // is what must drop it.
-      await mkdir(path.join(hqRoot, "repos", "some-repo"), { recursive: true });
-      const emitted = waitForEmit(watcher, 2500);
-      await writeFile(
-        path.join(hqRoot, "repos", "some-repo", "code.ts"),
-        "export const x = 1;\n",
-      );
-      expect(await emitted).toBe(false);
-    },
-    8000,
-  );
-});