@clankmates/cli 0.5.2 → 0.6.1

package/src/commands/inbox.ts

@@ -1,34 +1,40 @@
 import {
   integerFlag,
   requiredPositional,
-  requiredStringFlag,
   stringFlag,
   type ParsedArgs,
 } from "../lib/args";
 import { resolveBodyInput } from "../lib/body-input";
 import { createCommandContext, type CommandContext } from "../lib/context";
 import { CliError } from "../lib/errors";
+import {
+  formatTimestamp,
+  indent,
+  joinBlocks,
+  renderFields,
+  renderPagination,
+  renderSection,
+  shortId,
+} from "../lib/human";
 import { printJson, printValue, type Io } from "../lib/output";
-import type { MessageAttributes, ThreadAttributes } from "../types/api";
+import type {
+  InboxRecipient,
+  InboxSender,
+  MailboxFilter,
+  MessageAttributes,
+  ThreadAttributes,
+  ThreadStatusFilter,
+} from "../types/api";
 
 export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
   const subcommand = args.positionals[0];
   const context = await createCommandContext(args, io);
 
   switch (subcommand) {
-    case "requests": {
-      const response = await context.client.listInboxRequests({
-        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
-        cursor: stringFlag(args.flags, "cursor"),
-        channelToken: stringFlag(args.flags, "channelToken"),
-      });
-
-      printThreadCollection(context, io, response);
-      return;
-    }
-
-    case "conversations": {
-      const response = await context.client.listInboxConversations({
+    case "list": {
+      const response = await context.client.listInboxThreads({
+        status: parseStatusFilter(stringFlag(args.flags, "status")),
+        mailbox: parseMailboxFilter(stringFlag(args.flags, "mailbox")),
         limit: integerFlag(args.flags, "limit", { label: "--limit" }),
         cursor: stringFlag(args.flags, "cursor"),
         channelToken: stringFlag(args.flags, "channelToken"),
@@ -38,60 +44,41 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       return;
     }
 
-    case "get": {
-      const thread = await context.client.getThread(
-        requiredPositional(args.positionals, 1, "Missing thread id"),
-        stringFlag(args.flags, "channelToken"),
-      );
-
-      printValue(
-        io,
-        context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
-      );
-      return;
-    }
-
-    case "messages": {
-      const response = await context.client.listMessagesForThread({
-        threadId: requiredPositional(args.positionals, 1, "Missing thread id"),
+    case "show": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const channelToken = stringFlag(args.flags, "channelToken");
+      const thread = await context.client.getThread(threadId, channelToken);
+      const messages = await context.client.listMessagesForThread({
+        threadId,
         limit: integerFlag(args.flags, "limit", { label: "--limit" }),
         cursor: stringFlag(args.flags, "cursor"),
-        channelToken: stringFlag(args.flags, "channelToken"),
-      });
-
-      printMessageCollection(context, io, response);
-      return;
-    }
-
-    case "send-account-intro": {
-      const thread = await context.client.sendAccountIntro({
-        email: requiredStringFlag(args.flags, "email"),
-        body: (await resolveBodyInput({
-          flags: args.flags,
-          requireBody: true,
-        }))!,
-        senderChannelId: await resolveSenderChannelId(context, args),
-        contextPostId: stringFlag(args.flags, "contextPostId"),
-        channelToken: stringFlag(args.flags, "channelToken"),
+        channelToken,
       });
 
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? {
+              thread,
+              messages: messages.items,
+              nextCursor: messages.nextCursor,
+            }
+          : renderThreadWithMessages(thread, messages),
       );
       return;
     }
 
-    case "send-channel-intro": {
-      const thread = await context.client.sendChannelIntro({
-        channelId: requiredPositional(args.positionals, 1, "Missing target channel id"),
+    case "send": {
+      const thread = await context.client.createThread({
+        recipient: parseRecipient(
+          requiredPositional(args.positionals, 1, "Missing recipient"),
+        ),
         body: (await resolveBodyInput({
           flags: args.flags,
           requireBody: true,
         }))!,
-        senderChannelId: await resolveSenderChannelId(context, args),
+        from: await resolveSender(context, args),
         contextPostId: stringFlag(args.flags, "contextPostId"),
         channelToken: stringFlag(args.flags, "channelToken"),
       });
@@ -99,7 +86,9 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Created thread", thread),
       );
       return;
     }
@@ -107,26 +96,13 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
     case "reply": {
       const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
       const channelToken = stringFlag(args.flags, "channelToken");
-      const senderChannel = stringFlag(args.flags, "senderChannel");
-
-      if (senderChannel) {
-        const thread = await context.client.getThread(threadId, channelToken);
-
-        if (thread.attributes.mailbox_type === "account") {
-          throw new CliError(
-            "`--sender-channel` is only valid for replies in channel inbox threads.",
-            2,
-          );
-        }
-      }
-
-      const thread = await context.client.replyToThread({
+      const thread = await context.client.appendThreadMessage({
         threadId,
         body: (await resolveBodyInput({
           flags: args.flags,
           requireBody: true,
         }))!,
-        senderChannelId: await resolveSenderChannelId(context, args),
+        from: await resolveSender(context, args),
         contextPostId: stringFlag(args.flags, "contextPostId"),
         channelToken,
       });
@@ -134,12 +110,14 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Replied to thread", thread),
       );
       return;
     }
 
-    case "mark-seen": {
+    case "seen": {
       const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
       const thread = await context.client.markThreadSeen({
         threadId,
@@ -149,7 +127,9 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Marked thread as seen", thread),
       );
       return;
     }
@@ -164,7 +144,9 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Archived thread", thread),
       );
       return;
     }
@@ -179,7 +161,9 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Resolved thread", thread),
       );
       return;
     }
@@ -194,7 +178,9 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json" ? thread : formatThreadRecord(thread),
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Blocked thread", thread),
       );
       return;
     }
@@ -204,37 +190,37 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
   }
 }
 
-async function resolveSenderChannelId(
+async function resolveSender(
   context: CommandContext,
   args: ParsedArgs,
-): Promise<string | undefined> {
-  const senderChannel = stringFlag(args.flags, "senderChannel");
+): Promise<InboxSender | undefined> {
+  const from = stringFlag(args.flags, "from");
   const channelToken = stringFlag(args.flags, "channelToken");
 
-  if (!senderChannel) {
+  if (!from) {
     return undefined;
   }
 
-  if (looksLikeUuid(senderChannel)) {
-    return senderChannel;
+  if (looksLikeUuid(from)) {
+    return channelSender(from);
   }
 
   if (channelToken) {
     const whoami = await context.client.whoami(channelToken);
 
     if (whoami.actor.type === "channel") {
-      if (whoami.actor.name === senderChannel) {
-        return whoami.actor.id;
+      if (whoami.actor.name === from) {
+        return channelSender(whoami.actor.id);
       }
 
       throw new CliError(
-        "With `--channel-token`, `--sender-channel` must match the authenticated channel name or UUID.",
+        "With `--channel-token`, `--from` must match the authenticated channel name or UUID.",
         2,
       );
     }
   }
 
-  return context.client.resolveChannelId(senderChannel);
+  return channelSender(await context.client.resolveChannelId(from));
 }
 
 const UUID_PATTERN =
@@ -244,6 +230,133 @@ function looksLikeUuid(value: string): boolean {
   return UUID_PATTERN.test(value);
 }
 
+function channelSender(channelId: string): InboxSender {
+  return {
+    type: "channel",
+    address: {
+      kind: "id",
+      value: channelId,
+    },
+  };
+}
+
+function parseStatusFilter(value: string | undefined): ThreadStatusFilter | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  if (value === "pending" || value === "open" || value === "blocked" || value === "all") {
+    return value;
+  }
+
+  throw new CliError("--status must be one of: pending, open, blocked, all", 2);
+}
+
+function parseMailboxFilter(value: string | undefined): MailboxFilter | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  if (value === "account" || value === "channel" || value === "all") {
+    return value;
+  }
+
+  throw new CliError("--mailbox must be one of: account, channel, all", 2);
+}
+
+function parseRecipient(value: string): InboxRecipient {
+  if (value.startsWith("email:")) {
+    return {
+      type: "user",
+      address: {
+        kind: "email",
+        value: requireRecipientValue(value, "email:"),
+      },
+    };
+  }
+
+  if (value.startsWith("user:")) {
+    const user = requireRecipientValue(value, "user:");
+
+    if (looksLikeUuid(user)) {
+      return {
+        type: "user",
+        address: {
+          kind: "id",
+          value: user,
+        },
+      };
+    }
+
+    return {
+      type: "user",
+      address: {
+        kind: "handle",
+        value: user,
+      },
+    };
+  }
+
+  if (value.startsWith("channel:")) {
+    const channel = requireRecipientValue(value, "channel:");
+
+    if (looksLikeUuid(channel)) {
+      return {
+        type: "channel",
+        address: {
+          kind: "id",
+          value: channel,
+        },
+      };
+    }
+
+    const handleChannel = parseHandleChannel(channel);
+
+    if (handleChannel) {
+      return {
+        type: "channel",
+        address: {
+          kind: "owner_handle_and_channel_name",
+          owner_handle: handleChannel.ownerHandle,
+          channel_name: handleChannel.channelName,
+        },
+      };
+    }
+  }
+
+  throw new CliError(
+    "Recipient must use one of: email:<email>, user:<uuid>, user:@handle, channel:<uuid>, channel:@handle/<channel-name>",
+    2,
+  );
+}
+
+function requireRecipientValue(value: string, prefix: string): string {
+  const rest = value.slice(prefix.length).trim();
+
+  if (!rest) {
+    throw new CliError(`Recipient ${prefix} value cannot be empty`, 2);
+  }
+
+  return rest;
+}
+
+function parseHandleChannel(
+  value: string,
+): { ownerHandle: string; channelName: string } | undefined {
+  const [ownerHandle, channelName, ...extra] = value.split("/");
+
+  if (
+    extra.length > 0 ||
+    !ownerHandle ||
+    !channelName ||
+    !ownerHandle.startsWith("@")
+  ) {
+    return undefined;
+  }
+
+  return { ownerHandle, channelName };
+}
+
 function printThreadCollection(
   context: CommandContext,
   io: Io,
@@ -274,52 +387,126 @@ function printThreadCollection(
   );
 }
 
-function printMessageCollection(
-  context: CommandContext,
-  io: Io,
-  response: {
+function renderThreadWithMessages(
+  thread: { id: string; attributes: ThreadAttributes },
+  messages: {
     items: Array<{ id: string; attributes: MessageAttributes }>;
     nextCursor?: string;
   },
-): void {
-  if (context.outputMode === "json") {
-    printJson(io, {
-      items: response.items,
-      nextCursor: response.nextCursor,
-    });
-    return;
-  }
-
-  printValue(
-    io,
-    context.outputMode,
-    response.items.map((item) => ({
-      id: item.id,
-      insertedAt: item.attributes.inserted_at ?? "",
-      contextPostId: item.attributes.context_post_id ?? "",
-      body: item.attributes.body,
-    })),
-  );
+): string {
+  const attrs = thread.attributes;
+  const messageBlocks =
+    messages.items.length === 0
+      ? "No messages."
+      : messages.items.map(renderMessage).join("\n\n");
+
+  return joinBlocks([
+    `Thread ${thread.id}`,
+    renderFields([
+      ["Mailbox", attrs.mailbox_type],
+      ["Status", attrs.status],
+      ["Last message", formatTimestamp(attrs.last_message_at)],
+      ["Opened", formatTimestamp(attrs.opened_at)],
+      [
+        "Expires",
+        attrs.expires_at ? formatTimestamp(attrs.expires_at) : undefined,
+      ],
+    ]),
+    renderSection(
+      "Participants",
+      renderFields([
+        ["A owner", formatActor("user", attrs.participant_a_owner_id)],
+        ["A channel", formatActor("channel", attrs.participant_a_channel_id)],
+        ["A seen", formatTimestamp(attrs.participant_a_seen_at)],
+        [
+          "A archived",
+          attrs.participant_a_archived_at
+            ? formatTimestamp(attrs.participant_a_archived_at)
+            : undefined,
+        ],
+        [
+          "A blocked",
+          attrs.participant_a_blocked_at
+            ? formatTimestamp(attrs.participant_a_blocked_at)
+            : undefined,
+        ],
+        [
+          "A resolved",
+          attrs.participant_a_resolved_at
+            ? formatTimestamp(attrs.participant_a_resolved_at)
+            : undefined,
+        ],
+        ["B owner", formatActor("user", attrs.participant_b_owner_id)],
+        ["B channel", formatActor("channel", attrs.participant_b_channel_id)],
+        ["B seen", formatTimestamp(attrs.participant_b_seen_at)],
+        [
+          "B archived",
+          attrs.participant_b_archived_at
+            ? formatTimestamp(attrs.participant_b_archived_at)
+            : undefined,
+        ],
+        [
+          "B blocked",
+          attrs.participant_b_blocked_at
+            ? formatTimestamp(attrs.participant_b_blocked_at)
+            : undefined,
+        ],
+        [
+          "B resolved",
+          attrs.participant_b_resolved_at
+            ? formatTimestamp(attrs.participant_b_resolved_at)
+            : undefined,
+        ],
+      ]),
+    ),
+    renderSection("Messages", messageBlocks),
+    renderPagination(messages.nextCursor),
+  ]);
 }
 
-function formatThreadRecord(thread: {
+function renderMessage(message: {
   id: string;
-  attributes: ThreadAttributes;
-}): Record<string, string> {
-  return {
-    id: thread.id,
-    mailboxType: thread.attributes.mailbox_type,
-    status: thread.attributes.status,
-    lastMessageAt: thread.attributes.last_message_at ?? "",
-    openedAt: thread.attributes.opened_at ?? "",
-    expiresAt: thread.attributes.expires_at ?? "",
-    participantASeenAt: thread.attributes.participant_a_seen_at ?? "",
-    participantAArchivedAt: thread.attributes.participant_a_archived_at ?? "",
-    participantABlockedAt: thread.attributes.participant_a_blocked_at ?? "",
-    participantAResolvedAt: thread.attributes.participant_a_resolved_at ?? "",
-    participantBSeenAt: thread.attributes.participant_b_seen_at ?? "",
-    participantBArchivedAt: thread.attributes.participant_b_archived_at ?? "",
-    participantBBlockedAt: thread.attributes.participant_b_blocked_at ?? "",
-    participantBResolvedAt: thread.attributes.participant_b_resolved_at ?? "",
-  };
+  attributes: MessageAttributes;
+}): string {
+  const attrs = message.attributes;
+  const headingParts = [
+    formatTimestamp(attrs.inserted_at),
+    shortId(message.id),
+    formatActor("user", attrs.sender_owner_id),
+    formatActor("channel", attrs.sender_channel_id),
+  ].filter((part) => part !== "-");
+  const contextPost = attrs.context_post_id
+    ? `Context post: ${attrs.context_post_id}\n`
+    : "";
+
+  return `${headingParts.join("  ")}\n${indent(`${contextPost}${attrs.body}`)}`;
+}
+
+function renderThreadAction(
+  action: string,
+  thread: { id: string; attributes: ThreadAttributes },
+): string {
+  const attrs = thread.attributes;
+
+  return joinBlocks([
+    `${action}: ${thread.id}`,
+    renderFields([
+      ["Mailbox", attrs.mailbox_type],
+      ["Status", attrs.status],
+      ["Last message", formatTimestamp(attrs.last_message_at)],
+      ["Opened", formatTimestamp(attrs.opened_at)],
+      [
+        "Expires",
+        attrs.expires_at ? formatTimestamp(attrs.expires_at) : undefined,
+      ],
+    ]),
+  ]);
+}
+
+function formatActor(kind: "user" | "channel", id?: string | null): string {
+  if (!id) {
+    return "-";
+  }
+
+  return `${kind}:${shortId(id)}`;
 }