@indigoai-us/hq-cloud 6.14.50 → 6.15.1

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

@@ -1,143 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  createRunnerEmitter,
-  emitUncaughtRunnerError,
-  routeEvents,
-} from "./sync-runner-events.js";
-
-function makeStreams() {
-  const stdout: string[] = [];
-  const stderr: string[] = [];
-  return {
-    stdout,
-    stderr,
-    streams: {
-      stdout: { write: (chunk: string) => void stdout.push(chunk) },
-      stderr: { write: (chunk: string) => void stderr.push(chunk) },
-    },
-  };
-}
-
-describe("routeEvents", () => {
-  it("routes error + auth-error events to stderr, everything else to stdout", () => {
-    const { stdout, stderr, streams } = makeStreams();
-
-    routeEvents({ type: "error", message: "boom", path: "(runner)" }, streams);
-    routeEvents({ type: "auth-error", message: "no token" }, streams);
-    routeEvents({ type: "setup-needed" }, streams);
-
-    expect(stderr).toHaveLength(2);
-    expect(stdout).toHaveLength(1);
-    expect(JSON.parse(stderr[0])).toMatchObject({ type: "error" });
-    expect(JSON.parse(stderr[1])).toMatchObject({ type: "auth-error" });
-    expect(JSON.parse(stdout[0])).toMatchObject({ type: "setup-needed" });
-  });
-
-  it("routes the feedback_d2082110 visibility events (materialization-gap, conflicts-remaining) to stdout", () => {
-    const { stdout, stderr, streams } = makeStreams();
-
-    routeEvents(
-      {
-        type: "scope-materialization-gap",
-        company: "dpp",
-        count: 13,
-        samplePaths: ["projects/secret.md"],
-        syncMode: "shared",
-      },
-      streams,
-    );
-    routeEvents(
-      { type: "conflicts-remaining", count: 20, samplePaths: ["knowledge/notes.md"] },
-      streams,
-    );
-
-    expect(stderr).toHaveLength(0);
-    expect(stdout).toHaveLength(2);
-    expect(JSON.parse(stdout[0])).toMatchObject({
-      type: "scope-materialization-gap",
-      count: 13,
-      syncMode: "shared",
-    });
-    expect(JSON.parse(stdout[1])).toMatchObject({
-      type: "conflicts-remaining",
-      count: 20,
-    });
-  });
-});
-
-describe("emitUncaughtRunnerError (HQ-SYNC-WEB-6)", () => {
-  it("emits a CLASSIFIED error event to stderr — not a silent death — for an uncaught Error", () => {
-    const { stdout, stderr, streams } = makeStreams();
-
-    emitUncaughtRunnerError(new Error("network blip: ECONNRESET"), streams);
-
-    // No silent death: a parseable error event is on stderr, so the menubar's
-    // record_error/is_alertable_error path runs instead of the always-alert
-    // "unexplained crash" branch.
-    expect(stdout).toHaveLength(0);
-    expect(stderr).toHaveLength(1);
-    const event = JSON.parse(stderr[0]);
-    expect(event).toMatchObject({ type: "error", path: "(runner)" });
-    expect(event.message).toContain("network blip: ECONNRESET");
-  });
-
-  it("preserves the stack in the message when available (diagnostics)", () => {
-    const { stderr, streams } = makeStreams();
-    const err = new Error("kaboom");
-
-    emitUncaughtRunnerError(err, streams);
-
-    const event = JSON.parse(stderr[0]);
-    // Error.stack starts with the message; assert we carried the full stack.
-    expect(event.message).toContain("kaboom");
-    expect(event.message).toBe(err.stack ?? err.message);
-  });
-
-  it("stringifies a non-Error rejection (no throw, still a classified event)", () => {
-    const { stderr, streams } = makeStreams();
-
-    emitUncaughtRunnerError("plain string failure", streams);
-
-    const event = JSON.parse(stderr[0]);
-    expect(event).toMatchObject({
-      type: "error",
-      path: "(runner)",
-      message: "plain string failure",
-    });
-  });
-
-  it("falls back to a plain stderr line if routing itself throws (never fully silent)", () => {
-    const writes: string[] = [];
-    let calls = 0;
-    const streams = {
-      stdout: { write: () => true },
-      stderr: {
-        write: (chunk: string) => {
-          calls += 1;
-          // First write is the routed JSON event — make it throw to exercise the
-          // fallback; second write is the plain-line fallback we want to capture.
-          if (calls === 1) throw new Error("stderr exploded");
-          writes.push(chunk);
-          return true;
-        },
-      },
-    };
-
-    emitUncaughtRunnerError(new Error("orig failure"), streams);
-
-    expect(writes).toHaveLength(1);
-    expect(writes[0]).toContain("hq-sync-runner: uncaught error —");
-    expect(writes[0]).toContain("orig failure");
-  });
-
-  it("createRunnerEmitter shares the same error->stderr routing contract", () => {
-    const { stdout, stderr, streams } = makeStreams();
-    const emit = createRunnerEmitter(streams);
-
-    emit({ type: "error", message: "x", path: "(discovery)" });
-
-    expect(stdout).toHaveLength(0);
-    expect(stderr).toHaveLength(1);
-  });
-});

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

@@ -1,55 +0,0 @@
-import type { RunnerEvent } from "./sync-runner.js";
-
-export interface RunnerEventStreams {
-  stdout: { write: (chunk: string) => boolean | void };
-  stderr: { write: (chunk: string) => boolean | void };
-}
-
-const ERROR_TYPES: ReadonlySet<RunnerEvent["type"]> = new Set([
-  "error",
-  "auth-error",
-]);
-
-export function routeEvents(
-  event: RunnerEvent,
-  streams: RunnerEventStreams,
-): void {
-  const stream = ERROR_TYPES.has(event.type) ? streams.stderr : streams.stdout;
-  stream.write(`${JSON.stringify(event)}\n`);
-}
-
-export function createRunnerEmitter(
-  streams: RunnerEventStreams,
-): (event: RunnerEvent) => void {
-  return (event) => routeEvents(event, streams);
-}
-
-/**
- * Emit a CLASSIFIED `error` event for a top-level uncaught runner rejection,
- * BEFORE the process exits non-zero.
- *
- * The menubar (hq-sync) treats a non-zero runner exit with NO error event seen
- * at all as an "unexplained crash" and ALWAYS alerts on it. That is correct for
- * a real panic/OOM, but the historical top-level catch wrote only a plain
- * stderr line (not a protocol event) for EVERY uncaught rejection — so even a
- * benign cause that bubbled to the top (transient network blip, a
- * not-yet-provisioned 404, an expected ACL-scope skip) drove a false alert
- * (HQ-SYNC-WEB-6). Emitting a structured `{type:"error"}` event here routes the
- * failure through the menubar's `is_alertable_error` classifier, so the benign
- * cases are suppressed while genuine defects still surface.
- *
- * Best-effort: if routing itself throws, fall back to a plain stderr line so the
- * failure is never fully silent in the logs.
- */
-export function emitUncaughtRunnerError(
-  err: unknown,
-  streams: RunnerEventStreams,
-): void {
-  const message =
-    err instanceof Error ? (err.stack ?? err.message) : String(err);
-  try {
-    routeEvents({ type: "error", message, path: "(runner)" }, streams);
-  } catch {
-    streams.stderr.write(`hq-sync-runner: uncaught error — ${message}\n`);
-  }
-}

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

@@ -1,311 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { buildFanoutPlan, resolveMembershipsForRun } from "./sync-runner-planning.js";
-import type { VaultClientSurface } from "./sync-runner.js";
-
-const noopStderr = { write: () => true };
-
-function clientStub(overrides: Record<string, unknown> = {}): VaultClientSurface {
-  return {
-    entity: {
-      get: () => Promise.resolve(undefined),
-      listByType: () => Promise.resolve([]),
-    },
-    ...overrides,
-  } as unknown as VaultClientSurface;
-}
-
-describe("resolveMembershipsForRun — setup-needed reasons", () => {
-  // Each reason must come from its OWN trigger. Collapsing them back into a
-  // bare `setup-needed` is what left joiners unable to tell "you have no team"
-  // apart from "you have an invite waiting".
-  it("reports no-memberships when the membership list came back empty", async () => {
-    const result = await resolveMembershipsForRun({
-      personal: false,
-      companies: true,
-      client: clientStub(),
-      claims: null,
-      stderr: noopStderr,
-      runClaimDance: () => Promise.resolve(0),
-      listMemberships: () => Promise.resolve([]),
-    });
-
-    expect(result).toEqual({ status: "setup-needed", reason: "no-memberships" });
-  });
-
-  it("attaches pendingInviteCount when the claim dance left invites unconverted", async () => {
-    const result = await resolveMembershipsForRun({
-      personal: false,
-      companies: true,
-      client: clientStub(),
-      claims: { sub: "sub-1" } as never,
-      stderr: noopStderr,
-      runClaimDance: () => Promise.resolve(3),
-      listMemberships: () => Promise.resolve([]),
-    });
-
-    expect(result).toEqual({
-      status: "setup-needed",
-      reason: "no-memberships",
-      pendingInviteCount: 3,
-    });
-  });
-
-  it("omits pendingInviteCount rather than reporting zero", async () => {
-    const result = await resolveMembershipsForRun({
-      personal: false,
-      companies: true,
-      client: clientStub(),
-      claims: { sub: "sub-1" } as never,
-      stderr: noopStderr,
-      runClaimDance: () => Promise.resolve(0),
-      listMemberships: () => Promise.resolve([]),
-    });
-
-    expect(result).toEqual({ status: "setup-needed", reason: "no-memberships" });
-    expect("pendingInviteCount" in result).toBe(false);
-  });
-
-  it("does not report setup-needed at all when memberships exist", async () => {
-    const runClaimDance = vi.fn().mockResolvedValue(2);
-    const result = await resolveMembershipsForRun({
-      personal: false,
-      companies: true,
-      client: clientStub(),
-      claims: { sub: "sub-1" } as never,
-      stderr: noopStderr,
-      runClaimDance,
-      listMemberships: () => Promise.resolve([{ companyUid: "cmp_a" }]),
-    });
-
-    // Pending invites are only meaningful as an explanation for emptiness.
-    expect(result).toEqual({
-      status: "memberships",
-      memberships: [{ companyUid: "cmp_a" }],
-    });
-  });
-
-  it("skips the claim dance for an outpost while still listing memberships", async () => {
-    const client = clientStub();
-    const runClaimDance = vi.fn().mockResolvedValue(1);
-    const listMemberships = vi.fn().mockResolvedValue([{ companyUid: "cmp_a" }]);
-
-    const result = await resolveMembershipsForRun({
-      personal: false,
-      companies: true,
-      client,
-      claims: {
-        "custom:entityType": "outpost",
-        "custom:entityUid": "out_01JOUTPOST00000000000000",
-      },
-      stderr: noopStderr,
-      runClaimDance,
-      listMemberships,
-    });
-
-    expect(runClaimDance).not.toHaveBeenCalled();
-    expect(listMemberships).toHaveBeenCalledWith(client);
-    expect(result).toEqual({
-      status: "memberships",
-      memberships: [{ companyUid: "cmp_a" }],
-    });
-  });
-});
-
-describe("buildFanoutPlan — setup-needed reasons", () => {
-  it("resolves an agent machine identity to only its claimed personal vault", async () => {
-    const agentUid = "agt_01J9AGENTSELF0000000000000";
-    const listByType = vi.fn((type: string) =>
-      Promise.resolve(
-        type === "agent"
-          ? [
-              {
-                uid: agentUid,
-                slug: "agent-self",
-                type: "agent",
-                status: "active",
-                bucketName: `hq-vault-${agentUid}`,
-              },
-            ]
-          : [],
-      ),
-    );
-    const result = await buildFanoutPlan({
-      memberships: [],
-      companies: false,
-      personal: true,
-      skipPersonal: false,
-      client: clientStub({
-        entity: { get: () => Promise.resolve(undefined), listByType },
-      }),
-      claims: {
-        "custom:entityType": "agent",
-        "custom:entityUid": agentUid,
-      },
-      resolveSkipPersonal: () => false,
-    });
-
-    expect(listByType).toHaveBeenCalledWith("agent");
-    expect(result).toEqual({
-      status: "plan",
-      deferredUnresolved: 0,
-      plan: [
-        {
-          slug: "personal",
-          uid: agentUid,
-          bucketName: `hq-vault-${agentUid}`,
-          personalMode: true,
-          journalSlug: "__hq_personal_vault__",
-        },
-      ],
-    });
-  });
-
-  it("does not let an agent machine identity fall back to a person vault", async () => {
-    const listByType = vi.fn(() => Promise.resolve([]));
-    const result = await buildFanoutPlan({
-      memberships: [],
-      companies: false,
-      personal: true,
-      skipPersonal: false,
-      client: clientStub({
-        entity: { get: () => Promise.resolve(undefined), listByType },
-      }),
-      claims: {
-        "custom:entityType": "agent",
-        "custom:entityUid": "agt_01J9AGENTSELF0000000000000",
-      },
-      resolveSkipPersonal: () => false,
-    });
-
-    expect(listByType).toHaveBeenCalledWith("agent");
-    expect(result).toEqual({ status: "setup-needed", reason: "no-person-entity" });
-  });
-
-  it("folds the same agent personal target into a --companies plan", async () => {
-    const agentUid = "agt_01J9AGENTSELF0000000000000";
-    const result = await buildFanoutPlan({
-      memberships: [{ companyUid: "cmp_team" }],
-      companies: true,
-      personal: false,
-      skipPersonal: false,
-      client: clientStub({
-        entity: {
-          get: () =>
-            Promise.resolve({
-              uid: "cmp_team",
-              slug: "team",
-              type: "company",
-              status: "active",
-              bucketName: "hq-vault-cmp-team",
-            }),
-          listByType: (type: string) => {
-            expect(type).toBe("agent");
-            return Promise.resolve([
-              {
-                uid: agentUid,
-                slug: "agent-self",
-                type: "agent",
-                status: "active",
-                bucketName: `hq-vault-${agentUid}`,
-              },
-            ]);
-          },
-        },
-      }),
-      claims: {
-        "custom:entityType": "agent",
-        "custom:entityUid": agentUid,
-      },
-      resolveSkipPersonal: () => false,
-    });
-
-    expect(result).toMatchObject({
-      status: "plan",
-      plan: [
-        { uid: "cmp_team", slug: "team" },
-        {
-          uid: agentUid,
-          slug: "personal",
-          bucketName: `hq-vault-${agentUid}`,
-          personalMode: true,
-        },
-      ],
-    });
-  });
-
-  it("keeps the human personal target on the person collection", async () => {
-    const personUid = "prs_01J9PERSONSELF000000000000";
-    const listByType = vi.fn(() =>
-      Promise.resolve([
-        {
-          uid: personUid,
-          slug: "person-self",
-          type: "person",
-          status: "active",
-          bucketName: `hq-vault-${personUid}`,
-          createdAt: "2026-01-01T00:00:00.000Z",
-        },
-      ]),
-    );
-    const result = await buildFanoutPlan({
-      memberships: [],
-      companies: false,
-      personal: true,
-      skipPersonal: false,
-      client: clientStub({
-        entity: { get: () => Promise.resolve(undefined), listByType },
-      }),
-      claims: { sub: "human-sub" },
-      resolveSkipPersonal: () => false,
-    });
-
-    expect(listByType).toHaveBeenCalledWith("person");
-    expect(result).toMatchObject({
-      status: "plan",
-      plan: [{ uid: personUid, bucketName: `hq-vault-${personUid}` }],
-    });
-  });
-
-  it("reports no-person-entity when --personal has no resolvable personal target", async () => {
-    const result = await buildFanoutPlan({
-      memberships: [],
-      companies: false,
-      personal: true,
-      skipPersonal: false,
-      client: clientStub(),
-      claims: null,
-      resolveSkipPersonal: () => false,
-    });
-
-    expect(result).toEqual({ status: "setup-needed", reason: "no-person-entity" });
-  });
-
-  // A --companies run does not need a personal target to be useful, so an
-  // unresolvable one must not abort the whole run.
-  it("does not report no-person-entity for a --companies run", async () => {
-    const result = await buildFanoutPlan({
-      memberships: [{ companyUid: "cmp_a" }],
-      companies: true,
-      personal: false,
-      skipPersonal: false,
-      client: clientStub({
-        entity: {
-          get: () =>
-            Promise.resolve({
-              uid: "cmp_a",
-              slug: "acme",
-              type: "company",
-              status: "active",
-              bucketName: "bucket-a",
-            }),
-          listByType: () => Promise.resolve([]),
-        },
-      }),
-      claims: null,
-      resolveSkipPersonal: () => false,
-    });
-
-    expect(result.status).toBe("plan");
-  });
-});