@indigoai-us/hq-cloud 6.15.40 → 6.15.41

package/dist/bin/sync-runner.test.js

@@ -13,7 +13,7 @@ import * as path from "path";
 import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal, resolveSkipCompanies, selectObjectIOFactory, routeChangeToTarget, buildTargetedPushArgv, resolvePullScope, readPinnedPrefixes, SESSIONS_SCOPE_PREFIX, defaultCollectTelemetry, AUTH_REQUIRED_PASS_EXIT, } from "./sync-runner.js";
 import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
 import { setBandwidthGovernorForTesting } from "../bandwidth.js";
-import { FakeClock, } from "../watcher.js";
+import { FakeClock, TreeWatcher, } from "../watcher.js";
 import { adaptivePollMs, advanceMonotonicDeadline, journalEntriesForWatcherDelete, shouldQuarantineWatcherDeleteIntents, } from "./sync-runner-watch-loop.js";
 import { PERSONAL_VAULT_JOURNAL_SLUG, readJournal, writeJournal, } from "../journal.js";
 import { HQ_CLOUD_VERSION } from "../version.js";
@@ -3809,6 +3809,95 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
     });
 });
 describe("runRunnerWithLoop — event-push wiring", () => {
+    it("activates the watcher after a successful numeric --companies pass", async () => {
+        const watcher = makeWatcherStub();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            // The watch-loop seam may report a completed pass as a bare status.
+            // A successful status must not permanently suppress local watching.
+            runPass: vi.fn().mockResolvedValue(0),
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        expect(watcher.started).toBe(true);
+        triggerShutdown();
+        await loop;
+    });
+    it("keeps both personal and company roots in a --companies watcher", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-combined-watch-"));
+        fs.mkdirSync(path.join(hqRoot, "personal"), { recursive: true });
+        fs.mkdirSync(path.join(hqRoot, "companies", "indigo", "knowledge"), {
+            recursive: true,
+        });
+        fs.writeFileSync(path.join(hqRoot, "personal", "profile.md"), "personal");
+        fs.writeFileSync(path.join(hqRoot, "companies", "indigo", "knowledge", "guide.md"), "company");
+        let triggerShutdown = () => { };
+        let watchedRootCount = 0;
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", hqRoot], {
+            runPass: vi.fn().mockResolvedValue(completedPassOutcome()),
+            createWatcher: (options) => new TreeWatcher({
+                ...options,
+                backendFactory: ({ hqRoot, shouldEmit }) => {
+                    const roots = [
+                        path.join(hqRoot, "personal"),
+                        path.join(hqRoot, "companies"),
+                        path.join(hqRoot, "companies", "indigo"),
+                    ].filter((candidate) => shouldEmit(candidate, true));
+                    watchedRootCount = roots.length;
+                    return {
+                        close: () => { },
+                        needsKnownKinds: false,
+                        watchedPathCount: () => watchedRootCount,
+                    };
+                },
+            }),
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks();
+            expect(watchedRootCount).toBe(3);
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
+        }
+    });
+    it("warns once and continues poll-only when watcher startup fails", async () => {
+        const stderrWrite = vi
+            .spyOn(process.stderr, "write")
+            .mockImplementation(() => true);
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(completedPassOutcome()),
+            createWatcher: () => {
+                throw new Error("simulated watcher startup failure");
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks();
+            expect(stderrWrite.mock.calls.map(([chunk]) => String(chunk)).join("")).toContain("hq-sync-runner: event-push watcher unavailable; continuing poll-only: simulated watcher startup failure");
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            stderrWrite.mockRestore();
+        }
+    });
     it("does not start journal-reading watcher callbacks before the initial pass finishes", async () => {
         const watcher = makeWatcherStub();
         let maintenanceComplete = false;