@indigoai-us/hq-cloud 6.14.41 → 6.14.43

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

@@ -1552,17 +1552,12 @@ describe("per-company fanout", () => {
         expect(deps.stdout.events().some((event) => event.type === "all-complete")).toBe(false);
     });
     /**
-     * Regression test: AWS SDK v3 raises an opaque `UnknownError` (name and
-     * message both literally "UnknownError") when it cannot match a Node-side
-     * networking failure to a modeled exception. The actual root cause —
-     * ENOTFOUND from a stale DNS cache, ECONNRESET on a flapping link, etc. —
-     * is parked on `err.cause`. Pre-fix the per-company catch extracted only
-     * `err.message`, so an unactionable bare "UnknownError" reached operators
-     * and the underlying syscall/hostname were lost. The catch now runs the
-     * thrown value through `describeError`, which walks the cause chain and
-     * stitches a one-line diagnostic the operator can act on.
+     * AWS SDK v3 can wrap a Node-side DNS error in an opaque `UnknownError`.
+     * The cause-chain classifier must treat this exactly like the direct
+     * ENOTFOUND shape from HQ-SYNC-X: visible and retryable, never an exit-2
+     * company error.
      */
-    it("per-company error event surfaces cause-chain (ENOTFOUND from SDK UnknownError)", async () => {
+    it("classifies an SDK UnknownError whose cause is ENOTFOUND as transient (HQ-SYNC-X)", async () => {
         const deps = makeDeps({
             createVaultClient: () => makeVaultStub({
                 memberships: [{ companyUid: "cmp_x" }],
@@ -1588,18 +1583,119 @@ describe("per-company fanout", () => {
             }),
         });
         const code = await runRunner(["--companies"], deps);
-        expect(code).toBe(2);
-        const companyErr = deps.stderr
+        expect(code).toBe(TRANSIENT_NETWORK_EXIT);
+        expect(deps.stderr
+            .events()
+            .some((e) => e.type === "error" && e.company === "privy")).toBe(false);
+        const transient = deps.stdout
+            .events()
+            .find((e) => e.type === "transient-network");
+        expect(transient).toMatchObject({
+            company: "privy",
+            path: "(company)",
+        });
+        expect(transient?.message).toContain("UnknownError");
+        expect(transient?.message).toContain("ENOTFOUND");
+        expect(transient?.message).toContain("getaddrinfo");
+        expect(transient?.message).toContain("privy.s3.us-east-1.amazonaws.com");
+    });
+    it("returns 75, preserves the aborted complete event, and reports a direct ENOTFOUND leg as transient", async () => {
+        const transportError = Object.assign(new Error("getaddrinfo ENOTFOUND hq-vault-prs-test.s3.us-east-1.amazonaws.com"), { code: "ENOTFOUND" });
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_acme" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: "acme" }),
+            }),
+            sync: vi.fn().mockRejectedValue(transportError),
+        });
+        const code = await runRunner(["--companies"], deps);
+        expect(code).toBe(TRANSIENT_NETWORK_EXIT);
+        expect(deps.stderr
+            .events()
+            .some((e) => e.type === "error" && e.path === "(company)")).toBe(false);
+        expect(deps.stdout.events().find((e) => e.type === "transient-network")).toMatchObject({
+            company: "acme",
+            path: "(company)",
+            message: expect.stringContaining("code=ENOTFOUND"),
+        });
+        expect(deps.stdout.events().find((e) => e.type === "complete" && e.company === "acme")).toMatchObject({ aborted: true });
+        const all = deps.stdout
+            .events()
+            .find((e) => e.type === "all-complete");
+        expect(all.errors).toEqual([]);
+        expect(all.transient).toEqual([
+            {
+                company: "acme",
+                message: expect.stringContaining("code=ENOTFOUND"),
+            },
+        ]);
+        expect(all.companies).toEqual([
+            expect.objectContaining({ company: "acme", status: "transient-network" }),
+        ]);
+    });
+    it("keeps deterministic company failures as exit 2 errors", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_acme" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: "acme" }),
+            }),
+            sync: vi.fn().mockRejectedValue(new Error("AccessDenied: forbidden")),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(PARTIAL_SYNC_EXIT);
+        expect(deps.stderr.events().find((e) => e.type === "error" && e.company === "acme" && e.path === "(company)")).toBeDefined();
+        expect(deps.stdout
+            .events()
+            .some((e) => e.type === "transient-network")).toBe(false);
+    });
+    it("lets a real company error win over a transient company leg", async () => {
+        const dnsError = Object.assign(new Error("getaddrinfo ENOTFOUND vault"), {
+            code: "ENOTFOUND",
+        });
+        const slugs = { cmp_acme: "acme", cmp_beta: "beta" };
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_acme" }, { companyUid: "cmp_beta" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: slugs[uid] ?? uid }),
+            }),
+            sync: vi
+                .fn()
+                .mockRejectedValueOnce(dnsError)
+                .mockRejectedValueOnce(new Error("AccessDenied: forbidden")),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(PARTIAL_SYNC_EXIT);
+        expect(deps.stdout
+            .events()
+            .filter((e) => e.type === "transient-network")).toHaveLength(1);
+        expect(deps.stderr
+            .events()
+            .filter((e) => e.type === "error" && e.path === "(company)")).toHaveLength(1);
+    });
+    it("keeps a leg errored when a path error precedes a transient throw", async () => {
+        const dnsError = Object.assign(new Error("getaddrinfo ENOTFOUND vault"), {
+            code: "ENOTFOUND",
+        });
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_acme" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: "acme" }),
+            }),
+            sync: vi.fn().mockImplementation(async (opts) => {
+                opts.onEvent?.({
+                    type: "error",
+                    path: "locked.md",
+                    message: "AccessDenied: forbidden",
+                });
+                throw dnsError;
+            }),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(PARTIAL_SYNC_EXIT);
+        const all = deps.stdout
             .events()
-            .find((e) => e.type === "error" && e.company === "privy");
-        expect(companyErr).toBeDefined();
-        expect(companyErr?.path).toBe("(company)");
-        // The diagnostic must carry the original networking signal — without
-        // this the operator only sees "UnknownError" and the run is unactionable.
-        expect(companyErr?.message).toContain("UnknownError");
-        expect(companyErr?.message).toContain("ENOTFOUND");
-        expect(companyErr?.message).toContain("getaddrinfo");
-        expect(companyErr?.message).toContain("privy.s3.us-east-1.amazonaws.com");
+            .find((event) => event.type === "all-complete");
+        expect(all.transient).toEqual([expect.objectContaining({ company: "acme" })]);
+        expect(all.companies).toEqual([
+            expect.objectContaining({ company: "acme", status: "errored" }),
+        ]);
     });
     /**
      * Regression test for the rollup-bug from the personal-sync 401 incident.
@@ -1890,6 +1986,33 @@ describe("all-complete aggregate", () => {
         expect(events.find((event) => event.eventName === "sync_runner_completed"))
             .toMatchObject({ properties: { status: "partial" } });
     });
+    it("records a transient company leg without adding an errored-leg telemetry count", async () => {
+        const posts = [];
+        const client = {
+            ...makeVaultStub({
+                memberships: [{ companyUid: "cmp_a" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: "acme" }),
+            }),
+            postTelemetryEvents: vi.fn(async (batch) => {
+                posts.push(batch);
+                return { ok: true, written: batch.events.length, skipped: [] };
+            }),
+        };
+        const dnsError = Object.assign(new Error("getaddrinfo ENOTFOUND vault"), {
+            code: "ENOTFOUND",
+        });
+        const deps = makeDeps({
+            createVaultClient: () => client,
+            sync: vi.fn().mockRejectedValue(dnsError),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(TRANSIENT_NETWORK_EXIT);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const events = posts.flatMap((post) => post.events);
+        expect(events.find((event) => event.eventName === "company_sync_leg_completed"))
+            .toMatchObject({ properties: { status: "transient-network" } });
+        expect(events.find((event) => event.eventName === "sync_runner_completed"))
+            .toMatchObject({ properties: { status: "partial", errorCount: 0 } });
+    });
     it("retains terminal failure telemetry when post-client discovery fails", async () => {
         const posts = [];
         const client = {
@@ -1937,6 +2060,7 @@ describe("all-complete aggregate", () => {
             bytesUploaded: 0,
             conflictPaths: [],
             errors: [],
+            transient: [],
             partial: false,
             companies: [
                 {
@@ -2475,6 +2599,7 @@ describe("--direction", () => {
             bytesUploaded: 125,
             conflictPaths: [],
             errors: [],
+            transient: [],
             partial: false,
             companies: [
                 {
@@ -3633,6 +3758,40 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         expect(code).not.toBe(TRANSIENT_NETWORK_EXIT);
         expect(watcher.disposed).toBe(true);
     });
+    it("keeps the watch loop alive when a company leg returns transient exit 75 (HQ-SYNC-X)", async () => {
+        const watcher = makeWatcherStub();
+        const dnsError = Object.assign(new Error("getaddrinfo ENOTFOUND vault"), {
+            code: "ENOTFOUND",
+        });
+        const transientPass = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_acme" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: "acme" }),
+            }),
+            sync: vi.fn().mockRejectedValue(dnsError),
+        });
+        let passes = 0;
+        const runPass = vi.fn().mockImplementation(async () => {
+            passes += 1;
+            // End the otherwise-open watch loop with a later hard failure. The first
+            // pass uses the real company-leg fanout path, not a synthetic exit code.
+            return passes === 1 ? runRunner(["--companies"], transientPass) : 1;
+        });
+        const code = await runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => Promise.resolve(),
+            onShutdownSignal: () => () => { },
+        });
+        expect(runPass).toHaveBeenCalledTimes(2);
+        expect(code).toBe(1);
+        expect(code).not.toBe(TRANSIENT_NETWORK_EXIT);
+        expect(transientPass.stderr
+            .events()
+            .some((event) => event.type === "error" && event.path === "(company)")).toBe(false);
+        expect(watcher.disposed).toBe(true);
+    });
     it("a PARTIAL_SYNC_EXIT poll pass does NOT surface as a crash — the loop retries", async () => {
         // A partial pass (some per-file transfers threw: oversized object on an
         // old runner, presign denial, corrupt vault key) must keep