@indigoai-us/hq-cloud 6.2.7 → 6.3.1

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

@@ -13,6 +13,7 @@ import * as path from "path";
 import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal, resolvePresignTransport, routeChangeToTarget, buildTargetedPushArgv, resolvePullScope, readPinnedPrefixes, } from "./sync-runner.js";
 import { FakeClock } from "../watcher.js";
 import { PERSONAL_VAULT_JOURNAL_SLUG } from "../journal.js";
+import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
 import { VaultAuthError } from "../vault-client.js";
 // ---------------------------------------------------------------------------
 // Hermetic journal state — the runner now calls migratePersonalVaultJournal()
@@ -2850,4 +2851,265 @@ describe("readPinnedPrefixes", () => {
         expect(readPinnedPrefixes(root, "acme")).toEqual([]);
     });
 });
+// ---------------------------------------------------------------------------
+// Operation lock — one-shot sync takes it; the watch runner is exempt.
+// ---------------------------------------------------------------------------
+describe("runRunnerWithLoop — operation lock", () => {
+    const HQ = "/tmp/hq-oplock";
+    /** Write a live-holder lock (pid 1) for the HQ root into the test state dir. */
+    function writeLiveHolder(command) {
+        const p = lockPathFor(HQ);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify({ pid: 1, command, startedAt: new Date(0).toISOString(), hqRoot: HQ }));
+        return p;
+    }
+    it("one-shot sync refuses fast (exit 17) when another op holds the root", async () => {
+        const lp = writeLiveHolder("rescue");
+        const errs = [];
+        const spy = vi
+            .spyOn(process.stderr, "write")
+            .mockImplementation((chunk) => {
+            errs.push(String(chunk));
+            return true;
+        });
+        // No --watch → one-shot. Refusal short-circuits BEFORE runRunner (so no
+        // network / auth is touched).
+        const code = await runRunnerWithLoop(["--companies", "--hq-root", HQ]);
+        spy.mockRestore();
+        expect(code).toBe(OPERATION_LOCKED_EXIT);
+        expect(errs.join("")).toContain("rescue"); // names the holder
+        // The holder's lock is left intact — we refused, we didn't take it over.
+        const held = JSON.parse(fs.readFileSync(lp, "utf8"));
+        expect(held.pid).toBe(1);
+        expect(held.command).toBe("rescue");
+    });
+    it("the watch runner is EXEMPT — runs despite a held lock and never takes it", async () => {
+        const lp = writeLiveHolder("sync");
+        const watcher = makeWatcherStub();
+        let triggerShutdown = () => { };
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", HQ], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        // It started and ran a pass even though the lock is held → not blocked.
+        expect(watcher.started).toBe(true);
+        expect(runPass).toHaveBeenCalled();
+        triggerShutdown();
+        await loop;
+        // The pre-existing holder lock is untouched → the watcher never took it.
+        const held = JSON.parse(fs.readFileSync(lp, "utf8"));
+        expect(held.pid).toBe(1);
+        expect(held.command).toBe("sync");
+    });
+});
+function makeBatchWatcherStub() {
+    const listeners = new Set();
+    return {
+        disposed: false,
+        onChange(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        start() { },
+        stop() { },
+        dispose() {
+            this.disposed = true;
+            listeners.clear();
+        },
+        emit(changedRelPath, batch) {
+            for (const l of [...listeners])
+                l(changedRelPath, batch);
+        },
+    };
+}
+describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", () => {
+    const ENROLLED_CLAIMS = { email: "hassaan@getindigo.ai" };
+    const UNENROLLED_CLAIMS = { email: "someone@getindigo.ai" };
+    function runLoop(opts) {
+        const watcher = opts.watcher ?? makeBatchWatcherStub();
+        const runPass = opts.runPass ?? vi.fn().mockResolvedValue(0);
+        const clock = new FakeClock();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock,
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+            getIdTokenClaims: () => opts.claims,
+            getAccessToken: async () => "jwt-test",
+            startEventSync: (opts.startEventSync ??
+                vi.fn().mockResolvedValue(null)),
+        });
+        return { loop, watcher, runPass, clock, shutdown: () => triggerShutdown() };
+    }
+    async function microtasks(n = 6) {
+        for (let i = 0; i < n; i++)
+            await Promise.resolve();
+    }
+    it("gate OFF (unenrolled email): the event-sync seam is never consulted", async () => {
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const { loop, shutdown } = runLoop({
+            claims: UNENROLLED_CLAIMS,
+            startEventSync,
+        });
+        await microtasks();
+        shutdown();
+        await loop;
+        expect(startEventSync).not.toHaveBeenCalled();
+    });
+    it("gate OFF (no cached claims): the event-sync seam is never consulted", async () => {
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const { loop, shutdown } = runLoop({ claims: null, startEventSync });
+        await microtasks();
+        shutdown();
+        await loop;
+        expect(startEventSync).not.toHaveBeenCalled();
+    });
+    it("gate ON (enrolled email): wiring receives root, api url, auth + a sync bridge", async () => {
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const { loop, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+        });
+        await microtasks();
+        shutdown();
+        await loop;
+        expect(startEventSync).toHaveBeenCalledTimes(1);
+        const arg = startEventSync.mock.calls[0][0];
+        expect(arg.hqRoot).toBe("/tmp/hq");
+        expect(arg.apiUrl).toContain("https://");
+        expect(typeof arg.deviceId).toBe("string");
+        expect(arg.deviceId.length).toBeGreaterThan(0);
+        expect(typeof arg.resolveTenantId).toBe("function");
+        expect(typeof arg.syncFn).toBe("function");
+    });
+    it("publishes the batch ONLY after a successful targeted push pass", async () => {
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        const runPass = vi.fn().mockResolvedValue(0);
+        const { loop, watcher, clock, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+            runPass,
+        });
+        await microtasks(); // initial poll pass + async event-sync bring-up
+        runPass.mockClear();
+        const batch = {
+            paths: new Map([["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"]]),
+        };
+        watcher.emit("companies/indigo/a.md", batch);
+        clock.advance(0);
+        await microtasks();
+        // Targeted push ran and succeeded → batch published.
+        expect(runPass).toHaveBeenCalled();
+        expect(publishBatch).toHaveBeenCalledTimes(1);
+        expect(publishBatch.mock.calls[0][0]).toBe(batch);
+        shutdown();
+        await loop;
+    });
+    it("publishes NOTHING when the targeted push pass fails", async () => {
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        // Initial poll pass succeeds; the targeted pass fails.
+        const runPass = vi
+            .fn()
+            .mockResolvedValueOnce(0)
+            .mockResolvedValue(1);
+        const { loop, watcher, clock, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+            runPass,
+        });
+        await microtasks();
+        watcher.emit("companies/indigo/a.md", { paths: new Map([["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"]]) });
+        clock.advance(0);
+        await microtasks();
+        expect(publishBatch).not.toHaveBeenCalled();
+        shutdown();
+        await loop;
+    });
+    it("falls back to a synthesized single-path batch when the watcher emits a bare path", async () => {
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        const { loop, watcher, clock, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+        });
+        await microtasks();
+        watcher.emit("companies/indigo/b.md"); // no batch
+        clock.advance(0);
+        await microtasks();
+        expect(publishBatch).toHaveBeenCalledTimes(1);
+        const synthesized = publishBatch.mock.calls[0][0];
+        expect([...synthesized.paths.values()]).toEqual(["companies/indigo/b.md"]);
+        shutdown();
+        await loop;
+    });
+    it("disposes the event-sync handles on shutdown", async () => {
+        const dispose = vi.fn().mockResolvedValue(undefined);
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch: vi.fn(),
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose,
+        });
+        const { loop, shutdown } = runLoop({
+            claims: ENROLLED_CLAIMS,
+            startEventSync,
+        });
+        await microtasks();
+        shutdown();
+        await loop;
+        expect(dispose).toHaveBeenCalled();
+    });
+    it("env override HQ_SYNC_EVENT_SYNC=0 keeps the seam dormant for the enrolled account", async () => {
+        const prev = process.env.HQ_SYNC_EVENT_SYNC;
+        process.env.HQ_SYNC_EVENT_SYNC = "0";
+        try {
+            const startEventSync = vi.fn().mockResolvedValue(null);
+            const { loop, shutdown } = runLoop({
+                claims: ENROLLED_CLAIMS,
+                startEventSync,
+            });
+            await microtasks();
+            shutdown();
+            await loop;
+            expect(startEventSync).not.toHaveBeenCalled();
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = prev;
+        }
+    });
+});
 //# sourceMappingURL=sync-runner.test.js.map