@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/agents.test.ts

@@ -1,527 +0,0 @@
-/**
- * Unit tests for `hq agents` (agents.ts).
- *
- * Mirrors company.test.ts / members.test.ts: mock ensureCognitoToken +
- * getCompanyUid, spy on global fetch, drive through a Commander program, and
- * assert the /v1/agents request shape (method + path + body) plus the guard /
- * validation / exit behavior. `vaultApiFetch` itself is NOT mocked — the spied
- * global fetch verifies the real URL + init the helper produces.
- */
-
-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,
-    getCompanyUid: vi.fn(async () => "cmp_acme"),
-  };
-});
-
-import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { getCompanyUid } from "../utils/vault-api.js";
-import { registerAgentsCommand } from "./agents.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>;
-let logSpy: MockInstance<typeof console.log>;
-const mockEnsureCognitoToken = vi.mocked(ensureCognitoToken);
-const mockGetCompanyUid = vi.mocked(getCompanyUid);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  fetchSpy = vi.spyOn(globalThis, "fetch");
-  mockEnsureCognitoToken.mockResolvedValue("test-token");
-  mockGetCompanyUid.mockResolvedValue("cmp_acme");
-  exitSpy = vi.spyOn(process, "exit").mockImplementation((code?: number) => {
-    throw new Error(`process.exit(${code})`);
-  }) as unknown as MockInstance<typeof process.exit>;
-  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-  vi.spyOn(console, "error").mockImplementation(() => {});
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.name("hq").exitOverride();
-  registerAgentsCommand(program);
-  return program;
-}
-
-async function run(args: string[]): Promise<void> {
-  await buildProgram().parseAsync(["node", "hq", ...args]);
-}
-
-describe("hq agents list", () => {
-  it("GETs /v1/agents with the resolved companyUid", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, {
-        agents: [
-          { uid: "agt_1", name: "Ops", slug: "ops", agentStatus: "running" },
-        ],
-      }),
-    );
-
-    await run(["agents", "--company", "acme", "list"]);
-
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents");
-    expect(String(url)).toContain("companyUid=cmp_acme");
-    expect(init?.method ?? "GET").toBe("GET");
-  });
-
-  it("accepts --company on the subcommand too", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { agents: [] }));
-    await run(["agents", "list", "--company", "acme"]);
-    expect(mockGetCompanyUid).toHaveBeenCalledWith("test-token", "acme");
-  });
-
-  it("emits raw JSON with --json", async () => {
-    const stdoutSpy = vi
-      .spyOn(process.stdout, "write")
-      .mockImplementation(() => true);
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, { agents: [{ uid: "agt_1", name: "Ops", slug: "ops" }] }),
-    );
-    await run(["agents", "--company", "acme", "list", "--json"]);
-    const printed = stdoutSpy.mock.calls.map((c) => String(c[0])).join("\n");
-    expect(printed).toContain('"uid": "agt_1"');
-  });
-
-  it("prints a friendly message when agents are not enabled (404)", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(404, { error: "not found" }));
-    await run(["agents", "--company", "acme", "list"]);
-    const printed = logSpy.mock.calls.map((c) => String(c[0])).join("\n");
-    expect(printed).toMatch(/agents feature isn't enabled/i);
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("hq agents rename", () => {
-  it("PATCHes the profile with displayName", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, {
-        uid: "agt_1",
-        profile: { displayName: "New" },
-        slackUpdated: false,
-      }),
-    );
-
-    await run(["agents", "--company", "acme", "rename", "agt_1", "New"]);
-
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents/agt_1/profile");
-    expect(init?.method).toBe("PATCH");
-    expect(JSON.parse(init?.body as string)).toEqual({ displayName: "New" });
-  });
-});
-
-describe("hq agents set", () => {
-  it("PATCHes only the supplied profile fields", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, { uid: "agt_1", profile: {}, slackUpdated: true }),
-    );
-
-    await run([
-      "agents",
-      "--company",
-      "acme",
-      "set",
-      "agt_1",
-      "--title",
-      "Chief of Staff",
-    ]);
-
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents/agt_1/profile");
-    expect(init?.method).toBe("PATCH");
-    const sent = JSON.parse(init?.body as string);
-    expect(sent).toEqual({ title: "Chief of Staff" });
-  });
-
-  it("requires at least one field", async () => {
-    await expect(
-      run(["agents", "--company", "acme", "set", "agt_1"]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("hq agents config", () => {
-  it("PATCHes runtime-config with model/effort/tier", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, { uid: "agt_1", codexModel: "gpt-5.5", applied: true }),
-    );
-
-    await run([
-      "agents",
-      "--company",
-      "acme",
-      "config",
-      "agt_1",
-      "--model",
-      "gpt-5.5",
-      "--effort",
-      "high",
-      "--tier",
-      "priority",
-    ]);
-
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents/agt_1/runtime-config");
-    expect(init?.method).toBe("PATCH");
-    expect(JSON.parse(init?.body as string)).toEqual({
-      codexModel: "gpt-5.5",
-      codexReasoningEffort: "high",
-      codexServiceTier: "priority",
-    });
-  });
-
-  it("rejects an invalid --effort", async () => {
-    await expect(
-      run([
-        "agents",
-        "--company",
-        "acme",
-        "config",
-        "agt_1",
-        "--effort",
-        "turbo",
-      ]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("rejects an invalid --tier", async () => {
-    await expect(
-      run([
-        "agents",
-        "--company",
-        "acme",
-        "config",
-        "agt_1",
-        "--tier",
-        "turbo",
-      ]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("requires at least one field", async () => {
-    await expect(
-      run(["agents", "--company", "acme", "config", "agt_1"]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("hq agents start/stop/retry", () => {
-  it("POSTs /start", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { uid: "agt_1" }));
-    await run(["agents", "--company", "acme", "start", "agt_1"]);
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents/agt_1/start");
-    expect(init?.method).toBe("POST");
-  });
-
-  it("POSTs /stop", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { uid: "agt_1" }));
-    await run(["agents", "--company", "acme", "stop", "agt_1"]);
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/agents/agt_1/stop");
-  });
-
-  it("POSTs /retry", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { uid: "agt_1" }));
-    await run(["agents", "--company", "acme", "retry", "agt_1"]);
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/agents/agt_1/retry");
-  });
-});
-
-describe("hq agents rm", () => {
-  it("refuses without --yes and does not call the API", async () => {
-    await expect(
-      run(["agents", "--company", "acme", "rm", "agt_1"]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it("DELETEs the agent with --yes", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, { uid: "agt_1", terminal: true }),
-    );
-    await run(["agents", "--company", "acme", "rm", "agt_1", "--yes"]);
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents/agt_1");
-    expect(init?.method).toBe("DELETE");
-  });
-});
-
-describe("hq agents status", () => {
-  it("exits 1 on a non-2xx and surfaces the error", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(403, { error: "forbidden" }),
-    );
-    await expect(
-      run(["agents", "--company", "acme", "status", "agt_1"]),
-    ).rejects.toThrow("process.exit(1)");
-  });
-});
-
-describe("hq agents provision (billing gate)", () => {
-  it("refuses without --yes, prints the cost, and makes NO API call", async () => {
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    await expect(
-      run(["agents", "--company", "acme", "provision", "Ops Bot"]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-    const printed = errSpy.mock.calls
-      .map((c) => c.map(String).join(" "))
-      .join("\n");
-    expect(printed).toMatch(/\$100\.00\/month/);
-  });
-
-  it("POSTs /v1/agents with slugified name + idempotency key when --yes", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, { uid: "agt_new", slug: "ops-bot" }),
-    );
-    await run(["agents", "--company", "acme", "provision", "Ops Bot", "--yes"]);
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/agents");
-    expect(init?.method).toBe("POST");
-    const sent = JSON.parse(init?.body as string);
-    expect(sent.companyUid).toBe("cmp_acme");
-    expect(sent.name).toBe("Ops Bot");
-    expect(sent.slug).toBe("ops-bot");
-    expect(sent.codexAuthMode).toBe("subscription");
-    expect(typeof sent.idempotencyKey).toBe("string");
-    expect(sent.idempotencyKey.length).toBeGreaterThan(0);
-  });
-
-  it("mints a card-capture link on 402 billing_required and exits 1", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(
-        jsonResponse(402, {
-          error: "payment required",
-          code: "BILLING_REQUIRED",
-          billing: {
-            status: "billing_required",
-            setup: {
-              payerType: "company",
-              path: "/v1/billing/checkout/org",
-              method: "POST",
-              body: { companyUid: "cmp_acme" },
-            },
-          },
-        }),
-      )
-      .mockResolvedValueOnce(
-        jsonResponse(200, { url: "https://checkout.stripe.com/card" }),
-      );
-
-    const logSpyLocal = vi.spyOn(console, "log").mockImplementation(() => {});
-    await expect(
-      run(["agents", "--company", "acme", "provision", "Ops Bot", "--yes"]),
-    ).rejects.toThrow("process.exit(1)");
-
-    // Second call mints the checkout link the 402 pointed at.
-    expect(String(fetchSpy.mock.calls[1][0])).toContain(
-      "/v1/billing/checkout/org",
-    );
-    expect(JSON.parse(fetchSpy.mock.calls[1][1]?.body as string)).toEqual({
-      companyUid: "cmp_acme",
-    });
-    const printed = logSpyLocal.mock.calls.map((c) => String(c[0])).join("\n");
-    expect(printed).toContain("https://checkout.stripe.com/card");
-  });
-
-  it("surfaces the DECLINE reason on 402 payment_failed (message-first decoding)", async () => {
-    // The payment_failed envelope carries BOTH the generic error AND the
-    // friendly decline message — the decode must prefer `message` or the
-    // decline copy is lost and the operator sees "add a card" for a card
-    // that exists and was declined.
-    fetchSpy
-      .mockResolvedValueOnce(
-        jsonResponse(402, {
-          error: "payment required",
-          message:
-            "Your card was declined. Try a different card or contact your bank.",
-          code: "PAYMENT_FAILED",
-          billing: {
-            status: "payment_failed",
-            setup: {
-              payerType: "company",
-              path: "/v1/billing/checkout/org",
-              method: "POST",
-              body: { companyUid: "cmp_acme" },
-            },
-          },
-        }),
-      )
-      .mockResolvedValueOnce(
-        jsonResponse(200, { url: "https://checkout.stripe.com/update" }),
-      );
-
-    const logSpyLocal = vi.spyOn(console, "log").mockImplementation(() => {});
-    const errSpyLocal = vi.spyOn(console, "error").mockImplementation(() => {});
-    await expect(
-      run(["agents", "--company", "acme", "provision", "Ops Bot", "--yes"]),
-    ).rejects.toThrow("process.exit(1)");
-
-    const printed = [...errSpyLocal.mock.calls, ...logSpyLocal.mock.calls]
-      .map((c) => c.map(String).join(" "))
-      .join("\n");
-    expect(printed).toContain("declined");
-    expect(printed).not.toContain("No card on file");
-    expect(printed).toContain("https://checkout.stripe.com/update");
-  });
-
-  it("requires --api-key-env for --auth-mode apiKey (before any charge)", async () => {
-    await expect(
-      run([
-        "agents",
-        "--company",
-        "acme",
-        "provision",
-        "Ops Bot",
-        "--auth-mode",
-        "apiKey",
-        "--yes",
-      ]),
-    ).rejects.toThrow("process.exit(1)");
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("hq agents talk (message / thread)", () => {
-  function agentRow(uid: string, slug: string, name: string) {
-    return { uid, slug, name, companyUid: "cmp_acme" };
-  }
-
-  it("resolves an agent by slug and reads the thread", async () => {
-    // 1) roster lookup for slug→uid, 2) thread read
-    fetchSpy
-      .mockResolvedValueOnce(
-        jsonResponse(200, { agents: [agentRow("agt_deacon", "deacon", "Deacon")] }),
-      )
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          messages: [
-            {
-              eventId: "e1",
-              fromPersonUid: "prs_me",
-              body: "hi",
-              createdAt: "2026-07-13T10:00",
-              direction: "out",
-            },
-            {
-              eventId: "e2",
-              fromPersonUid: "agt_deacon",
-              fromDisplayName: "Deacon",
-              body: "hello back",
-              createdAt: "2026-07-13T10:01",
-              direction: "in",
-            },
-          ],
-        }),
-      );
-
-    const logs: string[] = [];
-    vi.spyOn(console, "log").mockImplementation((...a) => {
-      logs.push(a.map(String).join(" "));
-    });
-    await run(["agents", "--company", "acme", "thread", "deacon"]);
-
-    // roster call then thread call
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/agents");
-    const threadUrl = String(fetchSpy.mock.calls[1][0]);
-    expect(threadUrl).toContain("/v1/notify/thread");
-    expect(threadUrl).toContain("withPersonUid=agt_deacon");
-    const out = logs.join("\n");
-    expect(out).toContain("hello back");
-    expect(out).toContain("hi");
-  });
-
-  it("passes an agt_ uid straight through (no roster lookup)", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { messages: [] }));
-    await run(["agents", "thread", "agt_xyz"]);
-    // Only the thread call — no /v1/agents roster fetch.
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("withPersonUid=agt_xyz");
-    expect(mockGetCompanyUid).not.toHaveBeenCalled();
-  });
-
-  it("message --no-wait POSTs the DM and does not poll", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { ok: true })); // POST /v1/notify/dm
-    await run(["agents", "message", "agt_xyz", "--no-wait", "hello", "there"]);
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain("/v1/notify/dm");
-    expect(init?.method).toBe("POST");
-    expect(JSON.parse(init?.body as string)).toEqual({
-      toPersonUid: "agt_xyz",
-      body: "hello there",
-    });
-  });
-
-  it("message waits for and prints the agent's reply", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, { messages: [] })) // baseline read
-      .mockResolvedValueOnce(jsonResponse(200, { ok: true })) // POST dm
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          messages: [
-            {
-              eventId: "r1",
-              fromPersonUid: "agt_xyz",
-              fromDisplayName: "Xyz",
-              body: "on it",
-              createdAt: "2026-07-13T11:00",
-              direction: "in",
-            },
-          ],
-        }),
-      ); // first poll returns the reply
-
-    const logs: string[] = [];
-    vi.spyOn(console, "log").mockImplementation((...a) => {
-      logs.push(a.map(String).join(" "));
-    });
-    await run(["agents", "message", "agt_xyz", "--timeout", "10", "ping"]);
-    expect(logs.join("\n")).toContain("on it");
-  }, 10000);
-
-  it("requires a non-empty message", async () => {
-    await expect(
-      run(["agents", "message", "agt_xyz", "   "]),
-    ).rejects.toThrow("process.exit(1)");
-  });
-});