@indigoai-us/hq-cli 5.51.0 → 5.53.0

package/src/commands/company.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Unit tests for `hq company settings set` (company.ts).
+ *
+ * Mirrors members.test.ts: mock ensureCognitoToken + getEntityUid, spy on
+ * global fetch, drive through a Commander program, assert the PUT
+ * /company-settings request shape + exit behavior.
+ */
+
+import { Command } from "commander";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type MockInstance,
+} from "vitest";
+
+vi.mock("../utils/cognito-session.js", async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import("../utils/cognito-session.js")>();
+  return {
+    ...original,
+    ensureCognitoToken: vi.fn(async () => "test-token"),
+  };
+});
+
+vi.mock("../utils/vault-api.js", async (importOriginal) => {
+  const original = await importOriginal<typeof import("../utils/vault-api.js")>();
+  return {
+    ...original,
+    getEntityUid: vi.fn(async () => "cmp_acme"),
+  };
+});
+
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { getEntityUid } from "../utils/vault-api.js";
+import { registerCompanyCommand } from "./company.js";
+
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+let fetchSpy: MockInstance<typeof fetch>;
+let exitSpy: MockInstance<typeof process.exit>;
+const mockEnsureCognitoToken = vi.mocked(ensureCognitoToken);
+const mockGetEntityUid = vi.mocked(getEntityUid);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  fetchSpy = vi.spyOn(globalThis, "fetch");
+  mockEnsureCognitoToken.mockResolvedValue("test-token");
+  mockGetEntityUid.mockResolvedValue("cmp_acme");
+  exitSpy = vi
+    .spyOn(process, "exit")
+    .mockImplementation((code?: number) => {
+      throw new Error(`process.exit(${code})`);
+    }) as unknown as MockInstance<typeof process.exit>;
+  vi.spyOn(console, "log").mockImplementation(() => {});
+  vi.spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function buildProgram(): Command {
+  const program = new Command();
+  program.name("hq").exitOverride();
+  registerCompanyCommand(program);
+  return program;
+}
+
+async function run(args: string[]): Promise<void> {
+  await buildProgram().parseAsync(["node", "hq", ...args]);
+}
+
+describe("hq company settings set", () => {
+  it("PUTs crmEnabled=true with the resolved companyUid", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, { companySettings: { crmEnabled: true } }),
+    );
+
+    await run([
+      "company",
+      "settings",
+      "set",
+      "--company",
+      "acme",
+      "--crm-enabled",
+      "true",
+    ]);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchSpy.mock.calls[0];
+    expect(String(url)).toContain("/company-settings");
+    expect(init?.method).toBe("PUT");
+    const sent = JSON.parse(init?.body as string);
+    expect(sent).toMatchObject({ companyUid: "cmp_acme", crmEnabled: true });
+    expect(sent.ontologyEnabled).toBeUndefined();
+  });
+
+  it("PUTs both flags when both are supplied", async () => {
+    fetchSpy.mockResolvedValueOnce(jsonResponse(200, {}));
+
+    await run([
+      "company",
+      "settings",
+      "set",
+      "--company",
+      "acme",
+      "--crm-enabled",
+      "false",
+      "--ontology-enabled",
+      "true",
+    ]);
+
+    const sent = JSON.parse(fetchSpy.mock.calls[0][1]?.body as string);
+    expect(sent).toMatchObject({
+      companyUid: "cmp_acme",
+      crmEnabled: false,
+      ontologyEnabled: true,
+    });
+  });
+
+  it("requires at least one flag", async () => {
+    await expect(
+      run(["company", "settings", "set", "--company", "acme"]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("requires --company", async () => {
+    await expect(
+      run(["company", "settings", "set", "--crm-enabled", "true"]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("rejects a non-boolean flag value", async () => {
+    await expect(
+      run([
+        "company",
+        "settings",
+        "set",
+        "--company",
+        "acme",
+        "--crm-enabled",
+        "yes",
+      ]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 on a 403 (non-owner)", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(403, { error: "Requires owner role", code: "FORBIDDEN" }),
+    );
+
+    await expect(
+      run([
+        "company",
+        "settings",
+        "set",
+        "--company",
+        "acme",
+        "--crm-enabled",
+        "true",
+      ]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});

package/src/commands/company.ts

@@ -0,0 +1,132 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { vaultApiFetch, getEntityUid } from "../utils/vault-api.js";
+
+/**
+ * `hq company settings set` — owner-only per-company settings toggles
+ * (agency group-grants US-007 / hq-native-crm US-003). Wraps
+ * `PUT /company-settings`, setting the runtime-flippable `crmEnabled` /
+ * `ontologyEnabled` flags so an owner can enable the native CRM (and the
+ * ontology gardener) for a company without a redeploy.
+ *
+ * Conventions mirror `secrets.ts`: ensureCognitoToken() → getEntityUid() →
+ * vaultApiFetch() → error-check → chalk output.
+ */
+
+interface SettingsSetFlags {
+  crmEnabled?: string;
+  ontologyEnabled?: string;
+}
+
+/**
+ * Parse a `--flag <true|false>` string into a boolean, or throw. Commander
+ * passes the raw string; we validate strictly so a typo never silently writes
+ * the wrong value.
+ */
+function parseBoolFlag(value: string, flag: string): boolean {
+  const v = value.trim().toLowerCase();
+  if (v === "true") return true;
+  if (v === "false") return false;
+  throw new Error(`${flag} must be 'true' or 'false' (got '${value}')`);
+}
+
+export function registerCompanyCommand(program: Command): void {
+  const company = program
+    .command("company")
+    .description("Company-level settings")
+    .option("--company <slug>", "Company slug (resolves to companyUid)");
+
+  const settings = company
+    .command("settings")
+    .description("Per-company settings (owner-only)");
+
+  settings
+    .command("set")
+    .description(
+      "Set per-company settings (PUT /company-settings). Require at least one " +
+        "of --crm-enabled / --ontology-enabled.",
+    )
+    .option(
+      "--crm-enabled <true|false>",
+      "Enable/disable the native CRM for this company",
+    )
+    .option(
+      "--ontology-enabled <true|false>",
+      "Enable/disable the ontology gardener for this company",
+    )
+    .action(async (opts: SettingsSetFlags) => {
+      try {
+        const companySlug = company.opts().company as string | undefined;
+        if (!companySlug) {
+          console.error(chalk.red("Error: --company <slug> is required."));
+          process.exit(1);
+        }
+        if (opts.crmEnabled === undefined && opts.ontologyEnabled === undefined) {
+          console.error(
+            chalk.red(
+              "Error: provide at least one of --crm-enabled / --ontology-enabled.",
+            ),
+          );
+          process.exit(1);
+        }
+
+        const body: Record<string, unknown> = {};
+        if (opts.crmEnabled !== undefined) {
+          body.crmEnabled = parseBoolFlag(opts.crmEnabled, "--crm-enabled");
+        }
+        if (opts.ontologyEnabled !== undefined) {
+          body.ontologyEnabled = parseBoolFlag(
+            opts.ontologyEnabled,
+            "--ontology-enabled",
+          );
+        }
+
+        const token = await ensureCognitoToken();
+        const companyUid = await getEntityUid(token, { companySlug });
+        body.companyUid = companyUid;
+
+        const res = await vaultApiFetch({
+          token,
+          path: "/company-settings",
+          method: "PUT",
+          body,
+        });
+
+        if (!res.ok) {
+          const errBody = (await res.json().catch(() => ({}))) as Record<
+            string,
+            unknown
+          >;
+          if (res.status === 403) {
+            console.error(
+              chalk.red(
+                "Requires owner role on this company to change its settings.",
+              ),
+            );
+            process.exit(1);
+          }
+          console.error(
+            chalk.red(
+              `Failed to update company settings: ${(errBody.error as string) ?? res.statusText}`,
+            ),
+          );
+          process.exit(1);
+        }
+
+        const applied = Object.entries(body)
+          .filter(([k]) => k !== "companyUid")
+          .map(([k, v]) => `${k}=${v}`)
+          .join(", ");
+        console.log(
+          chalk.green(`Company settings updated for ${companySlug}: ${applied}`),
+        );
+      } catch (err) {
+        console.error(
+          chalk.red("Error:"),
+          err instanceof Error ? err.message : String(err),
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/commands/crm.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Unit tests for `hq crm entity upsert` (crm.ts).
+ *
+ * Mirrors members.test.ts: mock ensureCognitoToken + getEntityUid, spy on
+ * global fetch (vaultApiFetch's transport), drive the command through a
+ * Commander program, and assert the request shape + output / exit behavior.
+ */
+
+import { Command } from "commander";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type MockInstance,
+} from "vitest";
+
+vi.mock("../utils/cognito-session.js", async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import("../utils/cognito-session.js")>();
+  return {
+    ...original,
+    ensureCognitoToken: vi.fn(async () => "test-token"),
+  };
+});
+
+vi.mock("../utils/vault-api.js", async (importOriginal) => {
+  const original = await importOriginal<typeof import("../utils/vault-api.js")>();
+  return {
+    ...original,
+    getEntityUid: vi.fn(async () => "cmp_acme"),
+  };
+});
+
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { getEntityUid } from "../utils/vault-api.js";
+import { registerCrmCommand } from "./crm.js";
+
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+let fetchSpy: MockInstance<typeof fetch>;
+let exitSpy: MockInstance<typeof process.exit>;
+const mockEnsureCognitoToken = vi.mocked(ensureCognitoToken);
+const mockGetEntityUid = vi.mocked(getEntityUid);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  fetchSpy = vi.spyOn(globalThis, "fetch");
+  mockEnsureCognitoToken.mockResolvedValue("test-token");
+  mockGetEntityUid.mockResolvedValue("cmp_acme");
+  // process.exit(1) on the error paths — throw so the test can assert instead
+  // of tearing down the worker.
+  exitSpy = vi
+    .spyOn(process, "exit")
+    .mockImplementation((code?: number) => {
+      throw new Error(`process.exit(${code})`);
+    }) as unknown as MockInstance<typeof process.exit>;
+  vi.spyOn(console, "log").mockImplementation(() => {});
+  vi.spyOn(console, "error").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function buildProgram(): Command {
+  const program = new Command();
+  program.name("hq").exitOverride();
+  registerCrmCommand(program);
+  return program;
+}
+
+async function run(args: string[]): Promise<void> {
+  await buildProgram().parseAsync(["node", "hq", ...args]);
+}
+
+describe("hq crm entity upsert", () => {
+  it("flag form: POSTs a single entity to /crm/entities with external_ids", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        status: "written",
+        created: 1,
+        updated: 0,
+        skipped: 0,
+        errors: [],
+      }),
+    );
+
+    await run([
+      "crm",
+      "entity",
+      "upsert",
+      "--company",
+      "acme",
+      "--type",
+      "contact",
+      "--name",
+      "Jane Prospect",
+      "--attio-id",
+      "rec_jane",
+    ]);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchSpy.mock.calls[0];
+    expect(String(url)).toContain("/crm/entities");
+    expect(init?.method).toBe("POST");
+    const sent = JSON.parse(init?.body as string);
+    expect(sent.companyUid).toBe("cmp_acme");
+    expect(sent.entities).toHaveLength(1);
+    expect(sent.entities[0]).toMatchObject({
+      type: "contact",
+      canonical_name: "Jane Prospect",
+      external_ids: { attio: "rec_jane" },
+    });
+  });
+
+  it("exits 1 with a helpful message on 403 CRM_DISABLED", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(403, {
+        error: "the native CRM is not enabled for this company",
+        code: "CRM_DISABLED",
+      }),
+    );
+
+    await expect(
+      run([
+        "crm",
+        "entity",
+        "upsert",
+        "--company",
+        "acme",
+        "--type",
+        "contact",
+        "--name",
+        "Jane",
+      ]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("requires --company", async () => {
+    await expect(
+      run(["crm", "entity", "upsert", "--type", "contact", "--name", "Jane"]),
+    ).rejects.toThrow("process.exit(1)");
+    // Never made the request — failed before token resolution.
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("requires --type when no --json is given", async () => {
+    await expect(
+      run(["crm", "entity", "upsert", "--company", "acme", "--name", "Jane"]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("rejects an unknown --type", async () => {
+    await expect(
+      run([
+        "crm",
+        "entity",
+        "upsert",
+        "--company",
+        "acme",
+        "--type",
+        "widget",
+        "--name",
+        "Jane",
+      ]),
+    ).rejects.toThrow("process.exit(1)");
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+});