@indigoai-us/hq-cli 5.68.2 → 5.70.0

package/src/commands/dm.test.ts

@@ -18,6 +18,7 @@ vi.mock("../utils/cognito-session.js", async (importOriginal) => {
 });
 
 import { Command } from "commander";
+import chalk from "chalk";
 import {
   detectRecipient,
   parseDuration,
@@ -29,8 +30,18 @@ import {
   channelSlug,
   parseChannelName,
   matchChannelsByName,
+  senderLabel,
+  formatRelativeTime,
+  isUnread,
+  unreadEventIds,
+  filterUnread,
+  firstLine,
+  buildThreadQuery,
+  formatInboxEvent,
+  formatThreadMessage,
   type ConnectionRequest,
   type ChannelSummary,
+  type DmInboxEvent,
 } from "./dm.js";
 
 describe("parseGroupRecipients", () => {
@@ -262,6 +273,127 @@ describe("buildConnectionActionBody", () => {
 // Action handlers (HTTP/auth mocked)
 // ---------------------------------------------------------------------------
 
+describe("senderLabel", () => {
+  it("prefers display name, then email, then uid", () => {
+    expect(
+      senderLabel({ fromDisplayName: "Jonathan", fromEmail: "j@x.com", fromPersonUid: "prs_1" }),
+    ).toBe("Jonathan");
+    expect(senderLabel({ fromEmail: "j@x.com", fromPersonUid: "prs_1" })).toBe("j@x.com");
+    expect(senderLabel({ fromPersonUid: "prs_1" })).toBe("prs_1");
+    expect(senderLabel({})).toBe("unknown");
+  });
+});
+
+describe("formatRelativeTime", () => {
+  const now = Date.parse("2026-07-16T12:00:00.000Z");
+  it("renders sub-minute as 'just now'", () => {
+    expect(formatRelativeTime("2026-07-16T11:59:30.000Z", now)).toBe("just now");
+  });
+  it("renders minutes, hours, and days", () => {
+    expect(formatRelativeTime("2026-07-16T11:57:00.000Z", now)).toBe("3m ago");
+    expect(formatRelativeTime("2026-07-16T10:00:00.000Z", now)).toBe("2h ago");
+    expect(formatRelativeTime("2026-07-11T12:00:00.000Z", now)).toBe("5d ago");
+  });
+  it("falls back to a date for anything older than a week", () => {
+    expect(formatRelativeTime("2026-06-01T09:00:00.000Z", now)).toBe("2026-06-01");
+  });
+  it("echoes an unparseable input", () => {
+    expect(formatRelativeTime("not-a-date", now)).toBe("not-a-date");
+  });
+});
+
+describe("isUnread / unreadEventIds / filterUnread", () => {
+  const events: DmInboxEvent[] = [
+    { eventId: "a", body: "x", createdAt: "2026-07-16T11:00:00.000Z" },
+    {
+      eventId: "b",
+      body: "y",
+      createdAt: "2026-07-16T11:30:00.000Z",
+      acknowledgedAt: "2026-07-16T11:31:00.000Z",
+    },
+  ];
+  it("treats a message with no acknowledgedAt as unread", () => {
+    expect(isUnread(events[0])).toBe(true);
+    expect(isUnread(events[1])).toBe(false);
+  });
+  it("collects unread event ids", () => {
+    expect(unreadEventIds(events)).toEqual(["a"]);
+  });
+  it("filters to unread only", () => {
+    expect(filterUnread(events).map((e) => e.eventId)).toEqual(["a"]);
+  });
+});
+
+describe("firstLine", () => {
+  it("collapses whitespace to a single trimmed line", () => {
+    expect(firstLine("  hello\n  world  \t there ")).toBe("hello world there");
+  });
+  it("truncates with an ellipsis past the cap", () => {
+    const out = firstLine("abcdefghij", 5);
+    expect(out).toBe("abcd…");
+    expect(out.length).toBe(5);
+  });
+});
+
+describe("buildThreadQuery", () => {
+  it("routes an email through withEmail (lowercased)", () => {
+    expect(buildThreadQuery("Jonathan@GetIndigo.ai")).toEqual({
+      withEmail: "jonathan@getindigo.ai",
+    });
+  });
+  it("routes a personUid / agentUid through withPersonUid", () => {
+    expect(buildThreadQuery("prs_123")).toEqual({ withPersonUid: "prs_123" });
+    expect(buildThreadQuery("agt_123")).toEqual({ withPersonUid: "agt_123" });
+  });
+  it("rejects a bare name", () => {
+    expect(() => buildThreadQuery("Jonathan")).toThrow(/Resolve a name first/);
+  });
+});
+
+describe("format helpers (rendering)", () => {
+  beforeEach(() => {
+    chalk.level = 0; // plain text so assertions read the rendered content
+  });
+  const now = Date.parse("2026-07-16T12:00:00.000Z");
+  it("marks an unread inbox row with a bullet and shows the sender + body", () => {
+    const row = formatInboxEvent(
+      {
+        eventId: "e1",
+        fromDisplayName: "Jonathan Bach",
+        fromEmail: "jonathan@getindigo.ai",
+        body: "grp_jb_agent is created",
+        createdAt: "2026-07-16T11:57:00.000Z",
+      },
+      now,
+    );
+    expect(row).toContain("●");
+    expect(row).toContain("Jonathan Bach");
+    expect(row).toContain("<jonathan@getindigo.ai>");
+    expect(row).toContain("3m ago");
+    expect(row).toContain("grp_jb_agent is created");
+  });
+  it("tags thread direction: outgoing as 'you', incoming by sender", () => {
+    const out = formatThreadMessage(
+      { eventId: "o", body: "hey", createdAt: "2026-07-16T11:00:00.000Z", direction: "out" },
+      now,
+    );
+    expect(out).toContain("→");
+    expect(out).toContain("you");
+    const inbound = formatThreadMessage(
+      {
+        eventId: "i",
+        fromDisplayName: "Jonathan",
+        body: "thanks",
+        createdAt: "2026-07-16T11:30:00.000Z",
+        direction: "in",
+      },
+      now,
+    );
+    expect(inbound).toContain("←");
+    expect(inbound).toContain("Jonathan");
+  });
+});
+
 function jsonResponse(status: number, body: unknown): Response {
   return new Response(JSON.stringify(body), {
     status,
@@ -480,4 +612,137 @@ describe("dm command actions", () => {
     expect(body).toEqual({ withEmail: "spammer@example.com" });
     expect(logged()).toMatch(/Blocked — spammer@example\.com\./);
   });
+
+  // ---- receive side: inbox / thread / channel ----
+
+  it("inbox: lists incoming messages from GET /v1/notify/inbox", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        events: [
+          {
+            eventId: "e1",
+            fromDisplayName: "Jonathan Bach",
+            fromEmail: "jonathan@getindigo.ai",
+            body: "grp_jb_agent is created",
+            createdAt: "2026-07-16T11:57:00.000Z",
+          },
+        ],
+      }),
+    );
+    await program.parseAsync(["dm", "inbox"], { from: "user" });
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/inbox");
+    expect(logged()).toContain("Jonathan Bach");
+    expect(logged()).toContain("grp_jb_agent is created");
+    expect(errSpy).not.toHaveBeenCalled();
+  });
+
+  it("inbox --unread --mark-read: acks only the unread ids", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          events: [
+            { eventId: "u1", body: "new", createdAt: "2026-07-16T11:00:00.000Z" },
+            {
+              eventId: "r1",
+              body: "old",
+              createdAt: "2026-07-16T10:00:00.000Z",
+              acknowledgedAt: "2026-07-16T10:01:00.000Z",
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(jsonResponse(200, { acknowledged: 1 }));
+    await program.parseAsync(["dm", "inbox", "--unread", "--mark-read"], {
+      from: "user",
+    });
+    const ackCall = fetchSpy.mock.calls.find((c) =>
+      String(c[0]).includes("/v1/notify/inbox/ack"),
+    );
+    expect(ackCall).toBeTruthy();
+    expect(JSON.parse((ackCall![1]?.body as string) ?? "{}")).toEqual({
+      eventIds: ["u1"],
+    });
+  });
+
+  it("thread <email>: reads via withEmail and acks incoming messages", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          messages: [
+            {
+              eventId: "in1",
+              fromDisplayName: "Jonathan",
+              body: "thanks!",
+              createdAt: "2026-07-16T11:30:00.000Z",
+              direction: "in",
+            },
+            {
+              eventId: "out1",
+              body: "done",
+              createdAt: "2026-07-16T11:00:00.000Z",
+              direction: "out",
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(jsonResponse(200, { acknowledged: 1 }));
+    await program.parseAsync(["dm", "thread", "jonathan@getindigo.ai"], {
+      from: "user",
+    });
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/thread");
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("withEmail=");
+    const ackCall = fetchSpy.mock.calls.find((c) =>
+      String(c[0]).includes("/v1/notify/inbox/ack"),
+    );
+    expect(ackCall).toBeTruthy();
+    expect(JSON.parse((ackCall![1]?.body as string) ?? "{}")).toEqual({
+      eventIds: ["in1"],
+    });
+    expect(logged()).toContain("thanks!");
+  });
+
+  it("thread --no-ack: reads without marking anything read", async () => {
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        messages: [
+          {
+            eventId: "in1",
+            body: "hi",
+            createdAt: "2026-07-16T11:30:00.000Z",
+            direction: "in",
+          },
+        ],
+      }),
+    );
+    await program.parseAsync(["dm", "thread", "prs_x", "--no-ack"], {
+      from: "user",
+    });
+    expect(
+      fetchSpy.mock.calls.some((c) => String(c[0]).includes("/inbox/ack")),
+    ).toBe(false);
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("withPersonUid=prs_x");
+  });
+
+  it("channel <name>: resolves the channel then reads its messages", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse(200, channelsPayload))
+      .mockResolvedValueOnce(
+        jsonResponse(200, {
+          messages: [
+            {
+              eventId: "m1",
+              fromDisplayName: "Stefan",
+              body: "ship it",
+              createdAt: "2026-07-16T11:00:00.000Z",
+            },
+          ],
+        }),
+      );
+    await program.parseAsync(["dm", "channel", "vyg-dev"], { from: "user" });
+    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/channels");
+    expect(String(fetchSpy.mock.calls[1][0])).toContain(
+      "/v1/notify/channels/chn_v/messages",
+    );
+    expect(logged()).toContain("ship it");
+  });
 });