@andocorp/cli 0.1.0

package/src/cli-helpers.ts

@@ -0,0 +1,149 @@
+import * as Shared from "@ando/shared";
+import { DiscoveredWorkspace, Membership } from "./types.js";
+
+export function isChannel(membership: Membership) {
+  return membership.conversation.type === Shared.Models.ConversationType.CHANNEL;
+}
+
+function normalizeForMatch(value: string) {
+  return value.trim().toLowerCase();
+}
+
+export function compareByRecentActivity(left: Membership, right: Membership) {
+  const leftDate = new Date(
+    left.conversation.last_message_at ?? left.conversation.updated_at
+  ).getTime();
+  const rightDate = new Date(
+    right.conversation.last_message_at ?? right.conversation.updated_at
+  ).getTime();
+
+  return rightDate - leftDate;
+}
+
+export function getWorkspaceLabel(workspace: DiscoveredWorkspace) {
+  return `${workspace.name} (${workspace.slug})`;
+}
+
+export function resolveWorkspace(
+  workspaces: DiscoveredWorkspace[],
+  query: string | null
+) {
+  if (workspaces.length === 0) {
+    throw new Error("No workspaces were returned for this account.");
+  }
+
+  if (query == null || query.trim() === "") {
+    if (workspaces.length === 1) {
+      return workspaces[0] ?? null;
+    }
+
+    throw new Error("Multiple workspaces are available. Pass --workspace or choose one interactively.");
+  }
+
+  const normalizedQuery = normalizeForMatch(query);
+  const exactMatch =
+    workspaces.find((workspace) => {
+      return (
+        workspace.id === query ||
+        normalizeForMatch(workspace.slug) === normalizedQuery ||
+        normalizeForMatch(workspace.name) === normalizedQuery
+      );
+    }) ?? null;
+
+  if (exactMatch != null) {
+    return exactMatch;
+  }
+
+  const partialMatches = workspaces.filter((workspace) => {
+    return [workspace.id, workspace.slug, workspace.name].some((value) =>
+      normalizeForMatch(value).includes(normalizedQuery)
+    );
+  });
+
+  if (partialMatches.length === 1) {
+    return partialMatches[0] ?? null;
+  }
+
+  if (partialMatches.length === 0) {
+    throw new Error(`No workspace matched "${query}".`);
+  }
+
+  throw new Error(
+    `Workspace "${query}" is ambiguous: ${partialMatches
+      .slice(0, 8)
+      .map(getWorkspaceLabel)
+      .join(", ")}`
+  );
+}
+
+export function resolveConversation(
+  memberships: Membership[],
+  options: {
+    allowDms: boolean;
+    allowChannels: boolean;
+    query: string;
+  }
+) {
+  const filtered = memberships
+    .filter((membership) => {
+      if (!options.allowChannels && isChannel(membership)) {
+        return false;
+      }
+
+      if (!options.allowDms && !isChannel(membership)) {
+        return false;
+      }
+
+      return true;
+    })
+    .sort(compareByRecentActivity);
+
+  const normalizedQuery = normalizeForMatch(options.query);
+  const exactMatch =
+    filtered.find((membership) => {
+      return (
+        membership.conversation.id === options.query ||
+        normalizeForMatch(membership.conversation.name ?? "") === normalizedQuery
+      );
+    }) ?? null;
+
+  if (exactMatch != null) {
+    return exactMatch;
+  }
+
+  const partialMatches = filtered.filter((membership) => {
+    const fields = [
+      membership.conversation.id,
+      membership.conversation.name ?? "",
+      getConversationLabel(membership),
+    ];
+
+    return fields.some((value) =>
+      normalizeForMatch(value).includes(normalizedQuery)
+    );
+  });
+
+  if (partialMatches.length === 1) {
+    return partialMatches[0] ?? null;
+  }
+
+  if (partialMatches.length === 0) {
+    throw new Error(`No conversation matched "${options.query}".`);
+  }
+
+  throw new Error(
+    `Conversation "${options.query}" is ambiguous: ${partialMatches
+      .slice(0, 8)
+      .map((membership) => getConversationLabel(membership))
+      .join(", ")}`
+  );
+}
+
+export function getConversationLabel(membership: Membership) {
+  const prefix =
+    membership.conversation.type === Shared.Models.ConversationType.CHANNEL
+      ? "#"
+      : "@";
+
+  return `${prefix}${membership.conversation.name || membership.conversation.id}`;
+}

package/src/client.test.ts

@@ -0,0 +1,235 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createMe, createMessage } from "./test-helpers.js";
+
+const clientMocks = vi.hoisted(() => {
+  return {
+    action: vi.fn(),
+    constructor: vi.fn(),
+    mutation: vi.fn(),
+    query: vi.fn(),
+    setAuth: vi.fn(),
+  };
+});
+
+vi.mock("convex/browser", () => {
+  return {
+    ConvexHttpClient: class {
+      constructor(...args: unknown[]) {
+        clientMocks.constructor(...args);
+      }
+
+      action = clientMocks.action;
+      mutation = clientMocks.mutation;
+      query = clientMocks.query;
+      setAuth = clientMocks.setAuth;
+    },
+  };
+});
+
+vi.mock("../../convex/convex/_generated/api.js", () => {
+  return {
+    api: {
+      app: {
+        bootstrap: "bootstrap",
+        createMessage: "createMessage",
+        createReaction: "createReaction",
+        getMessage: "getMessage",
+        listConversationMessagesPaginated: "listConversationMessagesPaginated",
+        listThreadReplies: "listThreadReplies",
+      },
+      auth: {
+        discoverWorkspaces: "discoverWorkspaces",
+        refreshSessionJwt: "refreshSessionJwt",
+        selectWorkspace: "selectWorkspace",
+        sendEmailOtp: "sendEmailOtp",
+      },
+    },
+  };
+});
+
+describe("createAndoCliClient", () => {
+  beforeEach(() => {
+    clientMocks.action.mockReset();
+    clientMocks.constructor.mockReset();
+    clientMocks.mutation.mockReset();
+    clientMocks.query.mockReset();
+    clientMocks.setAuth.mockReset();
+  });
+
+  it("loads me from bootstrap", async () => {
+    const { createAndoCliClient } = await import("./client.js");
+    clientMocks.query.mockResolvedValue({
+      me: createMe({
+        created_at: 1_700_000_000_000 as unknown as Date,
+      }),
+      memberships: [],
+    });
+
+    const client = createAndoCliClient({
+      convexUrl: "https://convex.example.com",
+      sessionToken: "session-token",
+    });
+    const me = await client.getMe();
+
+    expect(clientMocks.setAuth).toHaveBeenCalledWith("session-token");
+    expect(clientMocks.query).toHaveBeenCalledWith("bootstrap", {});
+    expect(me?.workspace.name).toBe("Ando");
+    expect(me?.created_at).toBeInstanceOf(Date);
+  });
+
+  it("reuses the bootstrap result across me and memberships", async () => {
+    const { createAndoCliClient } = await import("./client.js");
+    clientMocks.query.mockResolvedValue({
+      me: createMe(),
+      memberships: [],
+    });
+
+    const client = createAndoCliClient({
+      convexUrl: "https://convex.example.com",
+      sessionToken: "session-token",
+    });
+
+    await client.getMe();
+    await client.getAllMemberships();
+
+    expect(clientMocks.query).toHaveBeenCalledTimes(1);
+    expect(clientMocks.query).toHaveBeenCalledWith("bootstrap", {});
+  });
+
+  it("constructs the authenticated Convex client once per CLI client", async () => {
+    const { createAndoCliClient } = await import("./client.js");
+    clientMocks.query
+      .mockResolvedValueOnce({
+        me: createMe(),
+        memberships: [],
+      })
+      .mockResolvedValueOnce({
+        page: [],
+        isDone: true,
+        continueCursor: "",
+      });
+
+    const client = createAndoCliClient({
+      convexUrl: "https://convex.example.com",
+      sessionToken: "session-token",
+    });
+
+    await client.getMe();
+    await client.getConversationMessages("conversation-1", 10);
+
+    expect(clientMocks.constructor).toHaveBeenCalledTimes(2);
+    expect(clientMocks.constructor).toHaveBeenNthCalledWith(
+      1,
+      "https://convex.example.com"
+    );
+    expect(clientMocks.constructor).toHaveBeenNthCalledWith(
+      2,
+      "https://convex.example.com"
+    );
+    expect(clientMocks.setAuth).toHaveBeenCalledTimes(1);
+    expect(clientMocks.setAuth).toHaveBeenCalledWith("session-token");
+  });
+
+  it("reverses paginated message results", async () => {
+    const { createAndoCliClient } = await import("./client.js");
+    clientMocks.query.mockResolvedValue({
+      page: [
+        createMessage({ id: "message-3", created_at: 3 as unknown as Date }),
+        createMessage({ id: "message-2", created_at: 2 as unknown as Date }),
+        createMessage({ id: "message-1", created_at: 1 as unknown as Date }),
+      ],
+      isDone: false,
+      continueCursor: "cursor-2",
+    });
+
+    const client = createAndoCliClient({
+      convexUrl: "https://convex.example.com",
+      sessionToken: "session-token",
+    });
+    const page = await client.getConversationMessages("conversation-1", 10);
+
+    expect(clientMocks.query).toHaveBeenCalledWith(
+      "listConversationMessagesPaginated",
+      {
+        conversationId: "conversation-1",
+        paginationOpts: {
+          cursor: null,
+          numItems: 10,
+        },
+      }
+    );
+    expect(page.items.map((item) => item.id)).toEqual([
+      "message-1",
+      "message-2",
+      "message-3",
+    ]);
+    expect(page.cursor).toBe("cursor-2");
+  });
+
+  it("posts a message with the Convex mutation payload the web app expects", async () => {
+    const { createAndoCliClient } = await import("./client.js");
+    clientMocks.mutation.mockResolvedValue(createMessage());
+
+    const client = createAndoCliClient({
+      convexUrl: "https://convex.example.com",
+      sessionToken: "session-token",
+    });
+
+    await client.postMessage({
+      conversationId: "conversation-1",
+      markdownContent: "hello",
+      threadRootId: "message-root",
+    });
+
+    expect(clientMocks.mutation).toHaveBeenCalledWith("createMessage", {
+      conversationId: "conversation-1",
+      clientRequestId: null,
+      markdownContent: "hello",
+      explicitContextMessageIds: [],
+      imageUrls: [],
+      fileIds: [],
+      initiatorId: null,
+      suppressedLinkPreviewUrls: [],
+      callRootId: null,
+      threadRootMessageId: "message-root",
+    });
+  });
+
+  it("adapts discovered workspaces returned by auth discovery", async () => {
+    const { createAndoCliClient } = await import("./client.js");
+    clientMocks.action.mockResolvedValue({
+      success: true,
+      workspaces: [
+        {
+          id: "workspace-1",
+          stytch_organization_id: "org-1",
+          name: "Ando",
+          slug: "ando",
+          image_url: null,
+          icon_image_file_id: null,
+          description: null,
+          invite_link_id: "invite-1",
+          created_at: 1_700_000_000_000,
+          updated_at: 1_700_000_000_000,
+          member_count: 3,
+        },
+      ],
+      intermediate_session_token: "intermediate-token",
+      requires_workspace_creation: false,
+    });
+
+    const client = createAndoCliClient({
+      convexUrl: "https://convex.example.com",
+    });
+    const discovery = await client.discoverWorkspaces({
+      email: "alex@ando.so",
+      code: "123456",
+    });
+
+    expect(clientMocks.action).toHaveBeenCalledWith("discoverWorkspaces", {
+      email: "alex@ando.so",
+      code: "123456",
+    });
+    expect(discovery.workspaces[0]?.created_at).toBeInstanceOf(Date);
+  });
+});