@indigoai-us/hq-cloud 6.13.3 → 6.13.5

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

@@ -16,6 +16,7 @@ import { FakeClock } from "../watcher.js";
 import { PERSONAL_VAULT_JOURNAL_SLUG } from "../journal.js";
 import { HQ_CLOUD_VERSION } from "../version.js";
 import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
+import { TRANSIENT_NETWORK_EXIT } from "../lib/net-errors.js";
 import { VaultAuthError } from "../vault-client.js";
 // ---------------------------------------------------------------------------
 // Hermetic journal state — the runner now calls migratePersonalVaultJournal()
@@ -68,6 +69,7 @@ function defaultSyncResult(overrides = {}) {
         filesOutOfScope: 0,
         scopeOrphansRemoved: 0,
         scopeOrphansBlocked: 0,
+        changedPaths: [],
         ...overrides,
     };
 }
@@ -134,6 +136,14 @@ function makeDeps(overrides = {}) {
         getAccessToken: vi.fn().mockResolvedValue("test-access-token"),
         createVaultClient: vi.fn().mockImplementation(() => makeVaultStub()),
         sync: vi.fn().mockResolvedValue(defaultSyncResult()),
+        reindex: vi.fn(() => ({ status: 0 })),
+        qmdReindex: vi.fn(() => ({
+            qmdAvailable: true,
+            collectionsAdded: [],
+            updated: true,
+            embedded: false,
+            pendingDirty: false,
+        })),
         ...overrides,
         stdout,
         stderr,
@@ -298,6 +308,47 @@ describe("memberships retry", () => {
             path: "(discovery)",
         });
     });
+    it("a transient network failure (fetch failed) during discovery returns TRANSIENT_NETWORK_EXIT, not 1 (HQ-SYNC-1W)", async () => {
+        // Regression for the "auto-sync watcher exited unexpectedly (code=Some(1))"
+        // cluster: a machine that stays offline through all 3 membership retries
+        // used to `return 1`, which the watch loop propagated and the menubar
+        // reported as a crash for every network blip. undici surfaces the blip as
+        // `TypeError: fetch failed`; that must map to the retryable exit code so the
+        // watcher stays alive instead of crash-reporting. A one-shot run still sees
+        // a non-zero exit.
+        let listCalls = 0;
+        const stub = makeVaultStub();
+        stub.listMyMemberships = () => {
+            listCalls++;
+            return Promise.reject(new TypeError("fetch failed"));
+        };
+        const deps = makeDeps({ createVaultClient: () => stub });
+        const code = await runRunner(["--companies"], deps);
+        expect(code).toBe(TRANSIENT_NETWORK_EXIT);
+        expect(listCalls).toBe(3);
+        // Still surfaced for observability — just no longer a "code 1" crash.
+        const events = deps.stderr.events();
+        expect(events).toHaveLength(1);
+        expect(events[0]).toMatchObject({
+            type: "error",
+            message: "fetch failed",
+            path: "(discovery)",
+        });
+    });
+    it("a NON-transient discovery failure still returns 1 (unchanged)", async () => {
+        // Guard the conservative classifier: a generic error (not a transport
+        // shape) is still a hard exit 1, exactly as before.
+        let listCalls = 0;
+        const stub = makeVaultStub();
+        stub.listMyMemberships = () => {
+            listCalls++;
+            return Promise.reject(new Error("unexpected 500 from vault api"));
+        };
+        const deps = makeDeps({ createVaultClient: () => stub });
+        const code = await runRunner(["--companies"], deps);
+        expect(code).toBe(1);
+        expect(listCalls).toBe(3);
+    });
     it("VaultAuthError short-circuits retry (no retries on auth failure)", async () => {
         let listCalls = 0;
         const stub = makeVaultStub();
@@ -1330,6 +1381,70 @@ describe("all-complete aggregate", () => {
             ],
         });
     });
+    it("skips per-target native reindex and runs one final reindex for tombstones or scope orphans", async () => {
+        const slugs = { cmp_a: "acme", cmp_b: "beta" };
+        const reindex = vi.fn(() => ({ status: 0 }));
+        const syncSpy = vi
+            .fn()
+            .mockResolvedValueOnce(defaultSyncResult({ filesTombstoned: 1 }))
+            .mockResolvedValueOnce(defaultSyncResult({ scopeOrphansRemoved: 1 }));
+        const deps = makeDeps({
+            operationLockAlreadyHeld: true,
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_a" }, { companyUid: "cmp_b" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: slugs[uid] ?? uid }),
+            }),
+            sync: syncSpy,
+            reindex,
+        });
+        const code = await runRunner(["--companies", "--hq-root", "/tmp/fake-hq"], deps);
+        expect(code).toBe(0);
+        expect(syncSpy).toHaveBeenCalledTimes(2);
+        expect(syncSpy.mock.calls.map(([opts]) => opts.skipReindex)).toEqual([
+            true,
+            true,
+        ]);
+        expect(reindex).toHaveBeenCalledTimes(1);
+        expect(reindex).toHaveBeenCalledWith({
+            repoRoot: "/tmp/fake-hq",
+            skipLock: true,
+        });
+    });
+    it("gates qmd to knowledge markdown changes and propagates hq-relative changed paths", async () => {
+        const slugs = { cmp_a: "acme", cmp_b: "beta" };
+        const qmdReindex = vi.fn(() => ({
+            qmdAvailable: true,
+            collectionsAdded: [],
+            updated: true,
+            embedded: false,
+            pendingDirty: false,
+        }));
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_a" }, { companyUid: "cmp_b" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: slugs[uid] ?? uid }),
+            }),
+            sync: vi
+                .fn()
+                .mockResolvedValueOnce(defaultSyncResult({
+                filesDownloaded: 1,
+                changedPaths: ["docs/readme.txt"],
+            }))
+                .mockResolvedValueOnce(defaultSyncResult({
+                filesTombstoned: 1,
+                changedPaths: ["knowledge/old.md"],
+            })),
+            reindex: vi.fn(() => ({ status: 0 })),
+            qmdReindex,
+        });
+        const code = await runRunner(["--companies", "--hq-root", "/tmp/fake-hq"], deps);
+        expect(code).toBe(0);
+        expect(qmdReindex).toHaveBeenCalledTimes(1);
+        expect(qmdReindex).toHaveBeenCalledWith("/tmp/fake-hq", expect.objectContaining({
+            changedPaths: ["companies/beta/knowledge/old.md"],
+            forceCollectionRefresh: true,
+        }));
+    });
     it("collects company-level errors into the all-complete errors array", async () => {
         const slugs = { cmp_a: "acme", cmp_b: "beta" };
         const deps = makeDeps({
@@ -2587,6 +2702,33 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         expect(code).toBe(2);
         expect(watcher.disposed).toBe(true);
     });
+    it("a TRANSIENT_NETWORK_EXIT poll pass does NOT surface as a crash — the loop retries (HQ-SYNC-1W)", async () => {
+        // A transient offline blip must keep the watcher alive: the loop logs and
+        // polls again instead of returning the code and letting the process exit
+        // (which the menubar reports as "watcher exited unexpectedly"). A genuine
+        // hard error on a later pass still terminates the loop.
+        const watcher = makeWatcherStub();
+        let n = 0;
+        const runPass = vi.fn().mockImplementation(async () => {
+            n++;
+            // First pass: machine is offline (transient). Second pass: a real hard
+            // error, used here only to end the otherwise-infinite loop deterministically.
+            return n === 1 ? TRANSIENT_NETWORK_EXIT : 2;
+        });
+        const code = await runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => Promise.resolve(),
+            onShutdownSignal: () => () => { },
+        });
+        // The transient pass did NOT end the loop — it ran again…
+        expect(runPass).toHaveBeenCalledTimes(2);
+        // …and the transient code was never surfaced as the watcher's exit code.
+        expect(code).toBe(2);
+        expect(code).not.toBe(TRANSIENT_NETWORK_EXIT);
+        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());