@indigoai-us/hq-cloud 6.14.23 → 6.14.25

package/src/bin/sync-runner.test.ts

@@ -16,6 +16,7 @@ import {
   runRunnerWithLoop,
   resolveDeletePolicy,
   resolveSkipPersonal,
+  resolveSkipCompanies,
   selectObjectIOFactory,
   routeChangeToTarget,
   buildTargetedPushArgv,
@@ -1091,6 +1092,114 @@ describe("fanout-plan", () => {
     expect(plan.companies).toEqual([{ uid: "cmp_ghost", slug: "cmp_ghost" }]);
   });
 
+  it("honors HQ_SYNC_SKIP_COMPANIES slug denylist in the fanout plan", async () => {
+    const prev = process.env.HQ_SYNC_SKIP_COMPANIES;
+    process.env.HQ_SYNC_SKIP_COMPANIES = "acme";
+    try {
+      const deps = makeDeps({
+        createVaultClient: () =>
+          makeVaultStub({
+            memberships: [{ companyUid: "cmp_a" }, { companyUid: "cmp_b" }],
+            entityGet: (uid: string) =>
+              Promise.resolve({
+                uid,
+                slug: uid === "cmp_a" ? "acme" : "beta",
+              } as unknown as EntityInfo),
+          }),
+      });
+
+      const code = await runRunner(["--companies"], deps);
+      expect(code).toBe(0);
+      const plan = deps.stdout
+        .events()
+        .find((e) => e.type === "fanout-plan") as Extract<
+        RunnerEvent,
+        { type: "fanout-plan" }
+      >;
+      expect(plan.companies.map((c) => c.slug)).toEqual(["beta"]);
+    } finally {
+      if (prev === undefined) delete process.env.HQ_SYNC_SKIP_COMPANIES;
+      else process.env.HQ_SYNC_SKIP_COMPANIES = prev;
+    }
+  });
+
+  it("fail-closes unresolved entities when a skip denylist is active", async () => {
+    const prev = process.env.HQ_SYNC_SKIP_COMPANIES;
+    process.env.HQ_SYNC_SKIP_COMPANIES = "paused-co";
+    try {
+      const deps = makeDeps({
+        createVaultClient: () =>
+          makeVaultStub({
+            memberships: [{ companyUid: "cmp_ambiguous" }],
+            entityGet: () => Promise.reject(new Error("transient discovery blip")),
+          }),
+      });
+
+      const code = await runRunner(["--companies"], deps);
+      // Omit ambiguous memberships from the plan, but retry (do not exit 0) so
+      // watch scoped drain cannot publish without a successful upload pass.
+      expect(code).toBe(TRANSIENT_NETWORK_EXIT);
+      const plan = deps.stdout
+        .events()
+        .find((e) => e.type === "fanout-plan") as Extract<
+        RunnerEvent,
+        { type: "fanout-plan" }
+      >;
+      // Without fail-closed, slug would stay as UID and bypass the slug denylist.
+      expect(plan.companies).toEqual([]);
+    } finally {
+      if (prev === undefined) delete process.env.HQ_SYNC_SKIP_COMPANIES;
+      else process.env.HQ_SYNC_SKIP_COMPANIES = prev;
+    }
+  });
+
+  it("still syncs resolved companies when denylist ambiguity forces a transient retry", async () => {
+    const prev = process.env.HQ_SYNC_SKIP_COMPANIES;
+    process.env.HQ_SYNC_SKIP_COMPANIES = "paused-co";
+    try {
+      const sync = vi.fn().mockResolvedValue(defaultSyncResult());
+      const deps = makeDeps({
+        createVaultClient: () =>
+          makeVaultStub({
+            memberships: [
+              { companyUid: "cmp_live" },
+              { companyUid: "cmp_ambiguous" },
+            ],
+            entityGet: (uid: string) => {
+              if (uid === "cmp_ambiguous") {
+                return Promise.reject(new Error("transient discovery blip"));
+              }
+              return Promise.resolve({
+                uid,
+                slug: "live",
+                type: "company",
+                status: "active",
+                createdAt: "2026-01-01T00:00:00Z",
+              });
+            },
+          }),
+        sync,
+      });
+
+      const code = await runRunner(["--companies"], deps);
+      expect(code).toBe(TRANSIENT_NETWORK_EXIT);
+      expect(sync).toHaveBeenCalledTimes(1);
+      expect(sync).toHaveBeenCalledWith(
+        expect.objectContaining({ company: "cmp_live" }),
+      );
+      const plan = deps.stdout
+        .events()
+        .find((e) => e.type === "fanout-plan") as Extract<
+        RunnerEvent,
+        { type: "fanout-plan" }
+      >;
+      expect(plan.companies.map((c) => c.slug)).toEqual(["live"]);
+    } finally {
+      if (prev === undefined) delete process.env.HQ_SYNC_SKIP_COMPANIES;
+      else process.env.HQ_SYNC_SKIP_COMPANIES = prev;
+    }
+  });
+
   it("skips a ghost membership whose entity is gone so it cannot force exit 2", async () => {
     const sync = vi.fn().mockResolvedValue(defaultSyncResult());
     const deps = makeDeps({
@@ -4789,6 +4898,21 @@ describe("resolveDeletePolicy", () => {
 // child-process default. Both surfaces tested so a regression on either
 // short-circuit path surfaces here.
 
+describe("resolveSkipCompanies", () => {
+  it("parses comma-separated slugs and drops personal", () => {
+    expect([...resolveSkipCompanies("acme, zeta ,personal,")].sort()).toEqual([
+      "acme",
+      "zeta",
+    ]);
+  });
+
+  it("returns empty set for missing / blank", () => {
+    expect(resolveSkipCompanies(undefined).size).toBe(0);
+    expect(resolveSkipCompanies("").size).toBe(0);
+    expect(resolveSkipCompanies("   ").size).toBe(0);
+  });
+});
+
 describe("resolveSkipPersonal", () => {
   let originalEnv: string | undefined;
 
@@ -5852,6 +5976,56 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
     await loop;
   });
 
+  it("publishes NOTHING for HQ_SYNC_SKIP_COMPANIES paused workspace edits", async () => {
+    const prev = process.env.HQ_SYNC_SKIP_COMPANIES;
+    process.env.HQ_SYNC_SKIP_COMPANIES = "indigo";
+    try {
+      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, tick, shutdown } = runLoop({
+        claims: ENROLLED_CLAIMS,
+        startEventSync,
+        runPass,
+      });
+      await microtasks();
+      runPass.mockClear();
+
+      watcher.emit("companies/indigo/a.md", {
+        paths: new Map([
+          ["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"],
+        ]),
+      });
+      clock.advance(0);
+      await microtasks();
+      tick();
+      await microtasks();
+
+      // Paused: no scoped push, no event-sync publish (path/hash must not leak).
+      expect(
+        runPass.mock.calls.filter((call) =>
+          (call[0] as string[]).includes("--company"),
+        ),
+      ).toEqual([]);
+      expect(publishBatch).not.toHaveBeenCalled();
+
+      shutdown();
+      await loop;
+    } finally {
+      if (prev === undefined) delete process.env.HQ_SYNC_SKIP_COMPANIES;
+      else process.env.HQ_SYNC_SKIP_COMPANIES = prev;
+    }
+  });
+
   it("does not publish an exit-zero deletion that the scoped push refused", async () => {
     const publishBatch = vi.fn();
     const startEventSync = vi.fn().mockResolvedValue({

package/src/bin/sync-runner.ts

@@ -144,9 +144,12 @@ import {
   buildFanoutPlan,
   emitFanoutPlan,
   resolveMembershipsForRun,
+  resolveSkipCompanies,
   type RunnerTarget,
   type SetupNeededReason,
 } from "./sync-runner-planning.js";
+
+export { resolveSkipCompanies } from "./sync-runner-planning.js";
 import {
   seedActiveCompany,
   type SeedActiveCompanyOptions,
@@ -394,6 +397,10 @@ export type RunnerEvent =
       Extract<SyncProgressEvent, { type: "skip-invalid-scoped-key" }>,
       "type"
     >)
+  | ({ type: "skip-junk-key-spelling"; company: string } & Omit<
+      Extract<SyncProgressEvent, { type: "skip-junk-key-spelling" }>,
+      "type"
+    >)
   | ({
       type: "complete";
       company: string;
@@ -1441,6 +1448,7 @@ export async function runRunner(
       client,
       claims,
       resolveSkipPersonal,
+      skipCompanies: resolveSkipCompanies(),
     });
   } catch (err) {
     if (err instanceof VaultAuthError) {
@@ -1461,6 +1469,7 @@ export async function runRunner(
     return 0;
   }
   const plan = targetPlan.plan;
+  const deferredUnresolved = targetPlan.deferredUnresolved;
 
   emitFanoutPlan(emit, plan);
 
@@ -1882,7 +1891,14 @@ export async function runRunner(
   // otherwise fire for normal user-policy outcomes. Consumers that want to
   // flag any non-clean outcome (clean-abort + thrown-error) read `partial`
   // from the JSON. The watch loop stays alive on this code (see exit-codes.ts).
-  return errors.length > 0 ? PARTIAL_SYNC_EXIT : 0;
+  //
+  // deferredUnresolved: a slug denylist was active but entity discovery blipped
+  // for one or more memberships we could not prove were paused. Fail closed on
+  // the plan (they were omitted) and return TRANSIENT so watch scoped drain
+  // does not publish without a successful upload pass.
+  if (errors.length > 0) return PARTIAL_SYNC_EXIT;
+  if (deferredUnresolved > 0) return TRANSIENT_NETWORK_EXIT;
+  return 0;
 }
 
 // ---------------------------------------------------------------------------