@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/meetings.test.ts

@@ -1,522 +0,0 @@
-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()) as Record<string, unknown>;
-  return {
-    ...original,
-    ensureCognitoToken: vi.fn(async () => "test-token"),
-  };
-});
-
-vi.mock("../utils/vault-api.js", async (importOriginal) => {
-  const original = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...original,
-    getCompanyUid: vi.fn(async (_token: string, slug: string) => `cmp_${slug}`),
-    vaultApiFetch: vi.fn(async () =>
-      new Response(JSON.stringify({ appliedToSeries: true }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-    ),
-  };
-});
-
-import { registerMeetingsCommand } from "./meetings.js";
-import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { getCompanyUid, vaultApiFetch } from "../utils/vault-api.js";
-
-let logSpy: MockInstance<typeof console.log>;
-let errSpy: MockInstance<typeof console.error>;
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
-  errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  vi.unstubAllGlobals();
-});
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  program.configureOutput({
-    writeOut: () => undefined,
-    writeErr: () => undefined,
-  });
-  registerMeetingsCommand(program);
-  return program;
-}
-
-function jsonRes(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-describe("meetings get — short id resolution", () => {
-  it("resolves an 8-char short id to the full id before calling the by-id endpoint", async () => {
-    const fullId = "589bfd78-aaaa-bbbb-cccc-1234567890ab";
-    vi.mocked(vaultApiFetch)
-      .mockResolvedValueOnce(
-        jsonRes({
-          meetings: [
-            {
-              meetingId: fullId,
-              title: "T",
-              status: "ready",
-              startTime: "2026-01-01T00:00:00Z",
-              endTime: "2026-01-01T00:00:00Z",
-              duration: 0,
-              participantCount: 0,
-              hasTranscript: false,
-              hasNotes: false,
-            },
-          ],
-        }),
-      )
-      .mockResolvedValueOnce(
-        jsonRes({
-          meetingId: fullId,
-          title: "T",
-          startTime: "2026-01-01T00:00:00Z",
-          endTime: "2026-01-01T00:00:00Z",
-          duration: 0,
-          participants: [],
-          calendarEventId: null,
-          botProvider: "recall",
-          sourceApp: "calendar",
-          companyId: "cmp_acme",
-          status: "ready",
-          recallBotId: null,
-          isShared: false,
-          createdAt: "2026-01-01T00:00:00Z",
-          updatedAt: "2026-01-01T00:00:00Z",
-          documentUrl: "",
-          hasTranscript: false,
-          hasNotes: false,
-        }),
-      );
-
-    const program = buildProgram();
-    await program.parseAsync(["node", "hq", "meetings", "get", "589bfd78"]);
-
-    expect(vaultApiFetch).toHaveBeenNthCalledWith(1, {
-      token: "test-token",
-      path: "/v1/meetings",
-      query: { limit: "500" },
-    });
-    expect(vaultApiFetch).toHaveBeenNthCalledWith(2, {
-      token: "test-token",
-      path: `/v1/meetings/${fullId}`,
-      query: {},
-    });
-  });
-
-  it("errors and never sends the truncated id when the short id matches no meeting", async () => {
-    vi.spyOn(process, "exit").mockImplementation((() => {
-      throw new Error("process.exit");
-    }) as never);
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes({ meetings: [] }));
-
-    const program = buildProgram();
-    await expect(
-      program.parseAsync(["node", "hq", "meetings", "get", "589bfd78"]),
-    ).rejects.toThrow("process.exit");
-
-    expect(errSpy).toHaveBeenCalledWith(
-      expect.stringContaining("No meeting matches ID \"589bfd78\""),
-    );
-    expect(vaultApiFetch).not.toHaveBeenCalledWith(
-      expect.objectContaining({ path: "/v1/meetings/589bfd78" }),
-    );
-  });
-});
-
-describe("meetings invite", () => {
-  it("authenticates and posts the meeting URL with the optional company routing", async () => {
-    const meetingUrl = "https://meet.google.com/abc-defg-hij";
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({
-        botId: "bot_123",
-        meetingUrl,
-        platform: "google_meet",
-        status: "scheduled",
-      }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "--company",
-      "indigo",
-      "invite",
-      meetingUrl,
-    ]);
-
-    expect(ensureCognitoToken).toHaveBeenCalledOnce();
-    expect(getCompanyUid).toHaveBeenCalledWith("test-token", "indigo");
-    expect(vaultApiFetch).toHaveBeenCalledWith({
-      token: "test-token",
-      method: "POST",
-      path: "/v1/bot/invite",
-      query: { companyId: "cmp_indigo" },
-      body: { meetingUrl },
-    });
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Meeting bot invited"));
-  });
-
-  it("omits company routing so the backend uses the caller's personal vault", async () => {
-    const meetingUrl = "https://zoom.us/j/123456789";
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({ botId: "bot_123", meetingUrl, status: "scheduled" }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync(["node", "hq", "meetings", "invite", meetingUrl]);
-
-    expect(getCompanyUid).not.toHaveBeenCalled();
-    expect(vaultApiFetch).toHaveBeenCalledWith({
-      token: "test-token",
-      method: "POST",
-      path: "/v1/bot/invite",
-      query: {},
-      body: { meetingUrl },
-    });
-  });
-});
-
-describe("meetings set-company", () => {
-  it("POSTs the resolved company id and applies to the recurring series by default", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({ appliedToSeries: true }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "set-company",
-      "meeting-123456",
-      "--company",
-      "acme",
-    ]);
-
-    expect(getCompanyUid).toHaveBeenCalledWith("test-token", "acme");
-    expect(vaultApiFetch).toHaveBeenCalledWith({
-      token: "test-token",
-      method: "POST",
-      path: "/v1/meetings/meeting-123456/company",
-      body: { companyId: "cmp_acme", applyToSeries: true },
-    });
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("sends unknown without resolving a target company", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({ appliedToSeries: true }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "set-company",
-      "meeting-123456",
-      "--company",
-      "unknown",
-    ]);
-
-    expect(getCompanyUid).not.toHaveBeenCalled();
-    expect(vaultApiFetch).toHaveBeenCalledWith({
-      token: "test-token",
-      method: "POST",
-      path: "/v1/meetings/meeting-123456/company",
-      body: { companyId: "unknown", applyToSeries: true },
-    });
-  });
-
-  it("sends applyToSeries false when --no-series is passed", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({ appliedToSeries: false }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "set-company",
-      "meeting-123456",
-      "--company",
-      "acme",
-      "--no-series",
-    ]);
-
-    expect(vaultApiFetch).toHaveBeenCalledWith({
-      token: "test-token",
-      method: "POST",
-      path: "/v1/meetings/meeting-123456/company",
-      body: { companyId: "cmp_acme", applyToSeries: false },
-    });
-  });
-
-  it("prints the raw response when --json is passed", async () => {
-    const body = { meetingId: "meeting-123456", companyId: "cmp_acme" };
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(body));
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "--json",
-      "set-company",
-      "meeting-123456",
-      "--company",
-      "acme",
-    ]);
-
-    expect(logSpy).toHaveBeenCalledWith(JSON.stringify(body, null, 2));
-  });
-
-  it("prints recurring series and refiled transcript counts from the response", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({
-        ok: true,
-        meetingId: "meeting-123456",
-        companyId: "cmp_acme",
-        seriesKey: "series-123",
-        appliedToSeries: true,
-        occurrencesUpdated: 3,
-        refiled: true,
-        refiledCount: 2,
-      }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "set-company",
-      "meeting-123456",
-      "--company",
-      "acme",
-    ]);
-
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Applied to 3 meetings in this recurring series"),
-    );
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Refiled 2 transcripts into the new company vault."),
-    );
-  });
-
-  it("does not print multi-meeting or refile copy for a single occurrence without refiles", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({
-        ok: true,
-        meetingId: "meeting-123456",
-        companyId: "cmp_acme",
-        seriesKey: null,
-        appliedToSeries: false,
-        occurrencesUpdated: 1,
-        refiled: false,
-        refiledCount: 0,
-      }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync([
-      "node",
-      "hq",
-      "meetings",
-      "set-company",
-      "meeting-123456",
-      "--company",
-      "acme",
-    ]);
-
-    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    expect(output).not.toContain("Applied to 1 meetings");
-    expect(output).not.toContain("Refiled 0 transcripts");
-    expect(output).not.toContain("Future occurrences of this recurring series will inherit this attribution.");
-  });
-});
-
-describe("meetings list — null-safe rendering", () => {
-  it("does not crash when a meeting has an undefined or null title", async () => {
-    // The API can return meetings with a missing/null title even though the
-    // type says string. This list previously crashed with
-    // "Cannot read properties of undefined (reading 'length')" after printing
-    // the header. Assert the command completes and renders a placeholder.
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({
-        meetings: [
-          {
-            meetingId: "589bfd78-aaaa-bbbb-cccc-1234567890ab",
-            // title intentionally omitted (undefined)
-            status: "ready",
-            startTime: "2026-01-01T00:00:00Z",
-            endTime: "2026-01-01T00:30:00Z",
-            duration: 1800,
-            participantCount: 3,
-            hasTranscript: true,
-            hasNotes: false,
-          },
-          {
-            meetingId: "689bfd78-aaaa-bbbb-cccc-1234567890ab",
-            title: null,
-            status: "ready",
-            startTime: "2026-01-02T00:00:00Z",
-            endTime: "2026-01-02T00:30:00Z",
-            duration: 1800,
-            participantCount: 1,
-            hasTranscript: false,
-            hasNotes: true,
-          },
-        ],
-      }),
-    );
-
-    const program = buildProgram();
-    await expect(
-      program.parseAsync(["node", "hq", "meetings", "list", "--company", "indigo"]),
-    ).resolves.toBeDefined();
-
-    const printed = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    expect(printed).toContain("Meetings (2)");
-    expect(printed).toContain("(untitled)");
-  });
-});
-
-describe("meetings — markdown shape rendering", () => {
-  const markdownMeetingId = "589bfd78-aaaa-bbbb-cccc-1234567890ab";
-  const markdownUrl = "https://example.test/meeting.md";
-
-  function markdownDetail(signals: Record<string, unknown> = {}) {
-    return {
-      meetingId: markdownMeetingId,
-      sourceShape: "markdown",
-      source: {
-        path: "meetings/meeting.md",
-        presigned_url: markdownUrl,
-        frontmatter: {
-          title: "Markdown Standup",
-          channel: "eng",
-          origin: "recall",
-          company_id: "cmp_indigo",
-          meeting_url: "https://meet.example.test/standup",
-          meeting_platform: "google_meet",
-          calendar_event_id: null,
-          scheduled_start_time: "2026-02-03T15:30:00Z",
-          created_at: "2026-02-03T15:00:00Z",
-          updated_at: "2026-02-03T16:00:00Z",
-          ingested_at: "2026-02-03T16:05:00Z",
-          recall_bot_id: null,
-          bot_status: "done",
-          auto_scheduled: true,
-        },
-      },
-      signals,
-    };
-  }
-
-  it("lists markdown meetings without invalid legacy field output", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
-      jsonRes({
-        meetings: [
-          {
-            meetingId: markdownMeetingId,
-            sourceShape: "markdown",
-            title: "Markdown Standup",
-            startTime: "2026-02-03T15:30:00Z",
-            channel: "eng",
-            ingested_at: "2026-02-03T16:05:00Z",
-            hasSignals: true,
-            companyId: "cmp_indigo",
-            attributed: true,
-          },
-        ],
-      }),
-    );
-
-    const program = buildProgram();
-    await program.parseAsync(["node", "hq", "meetings", "list"]);
-
-    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    expect(output).toContain("Markdown Standup");
-    expect(output).toContain(" S ");
-    expect(output).not.toContain("NaN");
-    expect(output).not.toContain("undefined");
-    expect(output).not.toContain("Invalid Date");
-  });
-
-  it("gets markdown details from frontmatter without reading participants", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(markdownDetail({ action_items: ["Ship fix"] })));
-
-    const program = buildProgram();
-    await expect(
-      program.parseAsync(["node", "hq", "meetings", "get", markdownMeetingId]),
-    ).resolves.toBeDefined();
-
-    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    expect(output).toContain("Markdown Standup");
-    expect(output).toContain("Status:      done");
-    expect(output).toContain("Platform:    google_meet");
-    expect(output).toContain("Origin:      recall");
-    expect(output).toContain("Company:     cmp_indigo");
-    expect(output).toContain("Meeting URL: https://meet.example.test/standup");
-    expect(output).toContain("Signals:     1");
-    expect(output).toContain("stored as a markdown document");
-  });
-
-  it("prints markdown transcript text from the presigned source URL", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(markdownDetail()));
-    const fetchMock = vi.fn(async () => new Response("# Markdown transcript\n\nHello team."));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const program = buildProgram();
-    await program.parseAsync(["node", "hq", "meetings", "transcript", markdownMeetingId]);
-
-    expect(fetchMock).toHaveBeenCalledWith(markdownUrl);
-    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    expect(output).toContain("Transcript: Markdown Standup");
-    expect(output).toContain("# Markdown transcript");
-    expect(output).toContain("Hello team.");
-  });
-
-  it("falls back to the markdown document for notes when markdown signals are empty", async () => {
-    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(markdownDetail({})));
-    vi.stubGlobal("fetch", vi.fn(async () => new Response("# Notes\n\nFollow up next week.")));
-
-    const program = buildProgram();
-    await program.parseAsync(["node", "hq", "meetings", "notes", markdownMeetingId]);
-
-    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    const errors = errSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
-    expect(output).toContain("Meeting Notes: Markdown Standup");
-    expect(output).toContain("# Notes");
-    expect(output).toContain("Follow up next week.");
-    expect(output).not.toContain("No document URL available");
-    expect(errors).not.toContain("No document URL available");
-  });
-});