@indigoai-us/hq-cloud 5.25.0 → 5.26.0

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

@@ -10,7 +10,8 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { runRunner, resolveDeletePolicy, resolveSkipPersonal } from "./sync-runner.js";
+import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal, routeChangeToTarget, buildTargetedPushArgv, } from "./sync-runner.js";
+import { FakeClock } from "../watcher.js";
 import { VaultAuthError } from "../vault-client.js";
 function makeWriter() {
     let buf = "";
@@ -1370,6 +1371,376 @@ describe("watch mode argv parsing", () => {
         expect(code).toBe(1);
         expect(deps.stderr.raw()).toContain("--poll-remote-ms requires --watch");
     });
+    it("accepts --event-push together with --watch (parser-level)", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({ memberships: [] }),
+        });
+        // One-shot single pass via runRunner (no loop) — the parser must accept
+        // --event-push as a known flag. No memberships → setup-needed → exit 0.
+        const code = await runRunner(["--companies", "--watch", "--event-push"], deps);
+        expect(deps.stderr.raw()).not.toContain("Unknown argument");
+        expect(code).toBe(0);
+    });
+    it("rejects --event-push without --watch (the flag has no meaning otherwise)", async () => {
+        const deps = makeDeps();
+        const code = await runRunner(["--companies", "--event-push"], deps);
+        expect(code).toBe(1);
+        expect(deps.stderr.raw()).toContain("--event-push requires --watch");
+    });
+    it("is OFF by default — plain --watch run does not require/accept event flags implicitly", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({ memberships: [] }),
+        });
+        const code = await runRunner(["--companies", "--watch"], deps);
+        expect(deps.stderr.raw()).not.toContain("Unknown argument");
+        expect(code).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// US-003 — event-driven push routing helpers (pure)
+// ---------------------------------------------------------------------------
+describe("routeChangeToTarget", () => {
+    it("routes companies/<slug>/... to a targeted company push", () => {
+        expect(routeChangeToTarget("companies/indigo/board.json")).toEqual({
+            kind: "company",
+            slug: "indigo",
+        });
+        expect(routeChangeToTarget("companies/acme/projects/x/prd.json")).toEqual({ kind: "company", slug: "acme" });
+    });
+    it("routes non-company top-levels to the personal target", () => {
+        expect(routeChangeToTarget("personal/notes.md")).toEqual({
+            kind: "personal",
+        });
+        expect(routeChangeToTarget("core/policies/x.md")).toEqual({
+            kind: "personal",
+        });
+        expect(routeChangeToTarget("README.md")).toEqual({ kind: "personal" });
+    });
+    it("normalizes OS path separators and ./ prefixes", () => {
+        expect(routeChangeToTarget(["companies", "indigo", "f.json"].join(path.sep))).toEqual({ kind: "company", slug: "indigo" });
+        expect(routeChangeToTarget("./companies/indigo/f.json")).toEqual({
+            kind: "company",
+            slug: "indigo",
+        });
+    });
+    it("returns null for unattributable paths (defensive)", () => {
+        expect(routeChangeToTarget("")).toBeNull();
+        expect(routeChangeToTarget("..")).toBeNull();
+        expect(routeChangeToTarget("../escape")).toBeNull();
+        // companies top-level with no slug segment is unattributable — a real
+        // edit always lands at companies/<slug>/..., never at bare "companies".
+        expect(routeChangeToTarget("companies")).toBeNull();
+        expect(routeChangeToTarget("companies/")).toBeNull();
+    });
+});
+describe("buildTargetedPushArgv", () => {
+    it("company route → --company <slug> --direction push", () => {
+        expect(buildTargetedPushArgv({ kind: "company", slug: "indigo" }, [
+            "--companies",
+            "--hq-root",
+            "/tmp/hq",
+            "--on-conflict",
+            "keep",
+        ])).toEqual([
+            "--company",
+            "indigo",
+            "--direction",
+            "push",
+            "--hq-root",
+            "/tmp/hq",
+            "--on-conflict",
+            "keep",
+        ]);
+    });
+    it("personal route → --companies --direction push (inherits root/conflict)", () => {
+        expect(buildTargetedPushArgv({ kind: "personal" }, [
+            "--companies",
+            "--hq-root",
+            "/tmp/hq",
+        ])).toEqual(["--companies", "--direction", "push", "--hq-root", "/tmp/hq"]);
+    });
+    it("carries no flags when the base argv has none", () => {
+        expect(buildTargetedPushArgv({ kind: "personal" }, ["--companies"])).toEqual(["--companies", "--direction", "push"]);
+    });
+});
+function makeWatcherStub() {
+    const listeners = new Set();
+    const stub = {
+        started: false,
+        disposed: false,
+        onChange(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        start() {
+            this.started = true;
+        },
+        stop() {
+            /* no-op for the stub */
+        },
+        dispose() {
+            this.disposed = true;
+            listeners.clear();
+        },
+        emit(changedRelPath) {
+            for (const l of [...listeners])
+                l(changedRelPath);
+        },
+    };
+    return stub;
+}
+describe("runRunnerWithLoop — event-push wiring", () => {
+    it("starts the watcher alongside the poll loop when --event-push is on", async () => {
+        const watcher = makeWatcherStub();
+        let triggerShutdown = () => { };
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }), // never resolves; shutdown ends it
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        // Let the first poll pass run, then shut down.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(watcher.started).toBe(true);
+        triggerShutdown();
+        await loop;
+        // The poll pass ran at least once (safety-net path still runs).
+        expect(runPass).toHaveBeenCalled();
+        expect(watcher.disposed).toBe(true);
+    });
+    it("trigger-on-change: a debounced changed signal runs a targeted company push", async () => {
+        const watcher = makeWatcherStub();
+        const clock = new FakeClock();
+        let triggerShutdown = () => { };
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock,
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        // Drain the initial poll pass.
+        await Promise.resolve();
+        await Promise.resolve();
+        runPass.mockClear();
+        // Fire a change for an indigo file; advance the (zero) driver window.
+        watcher.emit("companies/indigo/board.json");
+        clock.advance(0);
+        await Promise.resolve();
+        await Promise.resolve();
+        const targetedCall = runPass.mock.calls.find((c) => c[0].includes("--company"));
+        expect(targetedCall).toBeDefined();
+        expect(targetedCall[0]).toEqual([
+            "--company",
+            "indigo",
+            "--direction",
+            "push",
+            "--hq-root",
+            "/tmp/hq",
+        ]);
+        triggerShutdown();
+        await loop;
+    });
+    it("bare signal (no path) routes the targeted push to the personal vault", async () => {
+        const watcher = makeWatcherStub();
+        const clock = new FakeClock();
+        let triggerShutdown = () => { };
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock,
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        runPass.mockClear();
+        watcher.emit(); // no path — TreeWatcher's bare signal shape
+        clock.advance(0);
+        await Promise.resolve();
+        await Promise.resolve();
+        const personalCall = runPass.mock.calls.find((c) => c[0].includes("--companies") &&
+            c[0].includes("--direction"));
+        expect(personalCall).toBeDefined();
+        expect(personalCall[0]).toEqual([
+            "--companies",
+            "--direction",
+            "push",
+            "--hq-root",
+            "/tmp/hq",
+        ]);
+        triggerShutdown();
+        await loop;
+    });
+    it("overlap guard: a change during an in-flight pass does not start a concurrent pass", async () => {
+        const watcher = makeWatcherStub();
+        const clock = new FakeClock();
+        let triggerShutdown = () => { };
+        // A controllable in-flight pass: the first call hangs until we release it.
+        let release = () => { };
+        const firstGate = new Promise((r) => {
+            release = r;
+        });
+        let callCount = 0;
+        let maxConcurrent = 0;
+        let active = 0;
+        const runPass = vi.fn().mockImplementation(async () => {
+            active++;
+            maxConcurrent = Math.max(maxConcurrent, active);
+            callCount++;
+            if (callCount === 1)
+                await firstGate; // hold the first (poll) pass
+            active--;
+            return 0;
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock,
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        // The first poll pass is now in flight and gated.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(active).toBe(1);
+        // Fire a change while the pass is in flight → must be collapsed, not run.
+        watcher.emit("companies/indigo/x.json");
+        clock.advance(0);
+        await Promise.resolve();
+        await Promise.resolve();
+        // Still exactly one active pass; the watcher trigger did not overlap.
+        expect(maxConcurrent).toBe(1);
+        // Release the gated pass; the collapsed change re-arms and runs next.
+        release();
+        await Promise.resolve();
+        await Promise.resolve();
+        clock.advance(0);
+        await Promise.resolve();
+        await Promise.resolve();
+        // Never more than one pass concurrently across the whole run.
+        expect(maxConcurrent).toBe(1);
+        triggerShutdown();
+        await loop;
+    });
+    it("poll-still-runs: the poll loop fires passes independent of the watcher", async () => {
+        const watcher = makeWatcherStub();
+        let triggerShutdown = () => { };
+        let passes = 0;
+        // Box the resolver so TS control-flow doesn't narrow it to `null` at the
+        // call sites below (the assignment happens inside a deferred closure).
+        const poll = { resolve: null };
+        const runPass = vi.fn().mockImplementation(async () => {
+            passes++;
+            return 0;
+        });
+        // A sleep we can step: resolve once to allow a second poll pass.
+        const sleep = () => new Promise((resolve) => {
+            poll.resolve = resolve;
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        // First poll pass runs, then awaits sleep.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(passes).toBe(1);
+        // Step the poll interval → a second poll pass runs (safety net cadence).
+        poll.resolve?.();
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(passes).toBeGreaterThanOrEqual(2);
+        triggerShutdown();
+        // Release any pending sleep so the loop can observe shutdown and exit.
+        poll.resolve?.();
+        await loop;
+    });
+    it("clean shutdown: SIGTERM disposes the watcher and resolves the loop with no leaks", async () => {
+        const watcher = makeWatcherStub();
+        const clock = new FakeClock();
+        let triggerShutdown = () => { };
+        let detached = false;
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock,
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => {
+                    detached = true;
+                };
+            },
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(watcher.started).toBe(true);
+        triggerShutdown();
+        const code = await loop;
+        expect(code).toBe(0);
+        expect(watcher.disposed).toBe(true); // watcher torn down
+        expect(detached).toBe(true); // signal handler detached (no leaked listener)
+        // No pending FakeClock timers left behind by the driver's debounce.
+        expect(clock.pendingTimerCount()).toBe(0);
+    });
+    it("a non-zero poll pass exit returns immediately (hard error surfaces)", async () => {
+        const watcher = makeWatcherStub();
+        const runPass = vi.fn().mockResolvedValue(2);
+        const code = await runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => Promise.resolve(),
+            onShutdownSignal: () => () => { },
+        });
+        expect(code).toBe(2);
+        expect(watcher.disposed).toBe(true);
+    });
+    it("without --event-push, no watcher is created (poll-only safety net)", async () => {
+        let triggerShutdown = () => { };
+        const createWatcher = vi.fn(() => makeWatcherStub());
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch"], {
+            runPass,
+            createWatcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(createWatcher).not.toHaveBeenCalled();
+        expect(runPass).toHaveBeenCalled();
+        triggerShutdown();
+        await loop;
+    });
 });
 // ---------------------------------------------------------------------------
 // Re-initialize for each test (mock state hygiene)