@clankmates/cli 0.6.1 → 0.6.2

package/README.md

@@ -24,6 +24,20 @@ clankm auth --help
 clankm help channel token
 ```
 
+If you install through mise with `npm:@clankmates/cli = "latest"` and a new
+release does not appear after `mise upgrade`, refresh mise's remote-version
+cache for that invocation:
+
+```bash
+MISE_FETCH_REMOTE_VERSIONS_CACHE=0 mise upgrade npm:@clankmates/cli
+```
+
+You can also pin an exact release:
+
+```bash
+mise install npm:@clankmates/cli@0.6.2
+```
+
 For local development in this repository:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clankmates/cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "devDependencies": {
     "@types/bun": "1.3.10",
     "typescript": "^5.9.3"

package/src/commands/inbox.ts

@@ -24,6 +24,7 @@ import type {
   MessageAttributes,
   ThreadAttributes,
   ThreadStatusFilter,
+  WhoamiActor,
 } from "../types/api";
 
 export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
@@ -32,15 +33,16 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
 
   switch (subcommand) {
     case "list": {
+      const channelToken = stringFlag(args.flags, "channelToken");
       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"),
+        channelToken,
       });
 
-      printThreadCollection(context, io, response);
+      await printThreadCollection(context, io, response, channelToken);
       return;
     }
 
@@ -54,6 +56,13 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
         cursor: stringFlag(args.flags, "cursor"),
         channelToken,
       });
+      const ownerIds = ownerIdsForThreadDisplay(thread, messages.items);
+      const publicUsers =
+        context.outputMode === "json" || ownerIds.length === 0
+          ? new Map<string, string>()
+          : publicUserHandlesById(
+              (await context.client.listPublicUsersById(ownerIds)).items,
+            );
 
       printValue(
         io,
@@ -64,7 +73,7 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
               messages: messages.items,
               nextCursor: messages.nextCursor,
             }
-          : renderThreadWithMessages(thread, messages),
+          : renderThreadWithMessages(thread, messages, publicUsers),
       );
       return;
     }
@@ -357,27 +366,39 @@ function parseHandleChannel(
   return { ownerHandle, channelName };
 }
 
-function printThreadCollection(
+async function printThreadCollection(
   context: CommandContext,
   io: Io,
   response: {
     items: Array<{ id: string; attributes: ThreadAttributes }>;
     nextCursor?: string;
   },
-): void {
+  channelToken?: string,
+): Promise<void> {
   if (context.outputMode === "json") {
     printJson(io, {
       items: response.items,
       nextCursor: response.nextCursor,
     });
-    return;
+    return Promise.resolve();
   }
 
+  const actor = (await context.client.whoami(channelToken)).actor;
+  const peers = response.items.map((item) => threadPeer(item.attributes, actor));
+  const ownerIds = ownerIdsForThreadList(peers);
+  const publicUsers =
+    ownerIds.length === 0
+      ? new Map<string, string>()
+      : publicUserHandlesById(
+          (await context.client.listPublicUsersById(ownerIds)).items,
+        );
+
   printValue(
     io,
     context.outputMode,
-    response.items.map((item) => ({
+    response.items.map((item, index) => ({
       id: item.id,
+      with: formatThreadPeer(peers[index], publicUsers),
       mailboxType: item.attributes.mailbox_type,
       status: item.attributes.status,
       lastMessageAt: item.attributes.last_message_at ?? "",
@@ -393,12 +414,15 @@ function renderThreadWithMessages(
     items: Array<{ id: string; attributes: MessageAttributes }>;
     nextCursor?: string;
   },
+  publicUsers: Map<string, string>,
 ): string {
   const attrs = thread.attributes;
   const messageBlocks =
     messages.items.length === 0
       ? "No messages."
-      : messages.items.map(renderMessage).join("\n\n");
+      : messages.items
+          .map((message) => renderMessage(message, publicUsers))
+          .join("\n\n");
 
   return joinBlocks([
     `Thread ${thread.id}`,
@@ -415,7 +439,7 @@ function renderThreadWithMessages(
     renderSection(
       "Participants",
       renderFields([
-        ["A owner", formatActor("user", attrs.participant_a_owner_id)],
+        ["A owner", formatUserActor(attrs.participant_a_owner_id, publicUsers)],
         ["A channel", formatActor("channel", attrs.participant_a_channel_id)],
         ["A seen", formatTimestamp(attrs.participant_a_seen_at)],
         [
@@ -436,7 +460,7 @@ function renderThreadWithMessages(
             ? formatTimestamp(attrs.participant_a_resolved_at)
             : undefined,
         ],
-        ["B owner", formatActor("user", attrs.participant_b_owner_id)],
+        ["B owner", formatUserActor(attrs.participant_b_owner_id, publicUsers)],
         ["B channel", formatActor("channel", attrs.participant_b_channel_id)],
         ["B seen", formatTimestamp(attrs.participant_b_seen_at)],
         [
@@ -464,15 +488,18 @@ function renderThreadWithMessages(
   ]);
 }
 
-function renderMessage(message: {
-  id: string;
-  attributes: MessageAttributes;
-}): string {
+function renderMessage(
+  message: {
+    id: string;
+    attributes: MessageAttributes;
+  },
+  publicUsers: Map<string, string>,
+): string {
   const attrs = message.attributes;
   const headingParts = [
     formatTimestamp(attrs.inserted_at),
     shortId(message.id),
-    formatActor("user", attrs.sender_owner_id),
+    formatUserActor(attrs.sender_owner_id, publicUsers),
     formatActor("channel", attrs.sender_channel_id),
   ].filter((part) => part !== "-");
   const contextPost = attrs.context_post_id
@@ -510,3 +537,125 @@ function formatActor(kind: "user" | "channel", id?: string | null): string {
 
   return `${kind}:${shortId(id)}`;
 }
+
+function formatUserActor(
+  id: string | null | undefined,
+  publicUsers: Map<string, string>,
+): string {
+  if (!id) {
+    return "-";
+  }
+
+  return publicUsers.get(id) ?? formatActor("user", id);
+}
+
+function ownerIdsForThreadDisplay(
+  thread: { attributes: ThreadAttributes },
+  messages: Array<{ attributes: MessageAttributes }>,
+): string[] {
+  const ids = [
+    thread.attributes.participant_a_owner_id,
+    thread.attributes.participant_b_owner_id,
+    ...messages.map((message) => message.attributes.sender_owner_id),
+  ];
+
+  return Array.from(new Set(ids.filter((id): id is string => Boolean(id))));
+}
+
+function ownerIdsForThreadList(
+  peers: Array<ThreadPeer>,
+): string[] {
+  return Array.from(
+    new Set(
+      peers
+        .map((peer) => peer.ownerId)
+        .filter((id): id is string => Boolean(id)),
+    ),
+  );
+}
+
+interface ThreadPeer {
+  ownerId?: string | null;
+  channelId?: string | null;
+}
+
+function threadPeer(attrs: ThreadAttributes, actor: WhoamiActor): ThreadPeer {
+  const side = threadActorSide(attrs, actor);
+
+  if (side === "a") {
+    return {
+      ownerId: attrs.participant_b_owner_id,
+      channelId: attrs.participant_b_channel_id,
+    };
+  }
+
+  if (side === "b") {
+    return {
+      ownerId: attrs.participant_a_owner_id,
+      channelId: attrs.participant_a_channel_id,
+    };
+  }
+
+  return {
+    ownerId: attrs.participant_a_owner_id,
+    channelId: attrs.participant_a_channel_id,
+  };
+}
+
+function threadActorSide(
+  attrs: ThreadAttributes,
+  actor: WhoamiActor,
+): "a" | "b" | undefined {
+  if (actor.type === "channel") {
+    if (attrs.participant_a_channel_id === actor.id) {
+      return "a";
+    }
+
+    if (attrs.participant_b_channel_id === actor.id) {
+      return "b";
+    }
+  }
+
+  const ownerId = actor.type === "user" ? actor.id : actor.owner_id;
+
+  if (attrs.participant_a_owner_id === ownerId) {
+    return "a";
+  }
+
+  if (attrs.participant_b_owner_id === ownerId) {
+    return "b";
+  }
+
+  return undefined;
+}
+
+function formatThreadPeer(
+  peer: ThreadPeer | undefined,
+  publicUsers: Map<string, string>,
+): string {
+  if (!peer) {
+    return "-";
+  }
+
+  if (peer.channelId) {
+    return formatActor("channel", peer.channelId);
+  }
+
+  return formatUserActor(peer.ownerId, publicUsers);
+}
+
+function publicUserHandlesById(
+  users: Array<{ id: string; attributes: { public_handle?: string | null } }>,
+): Map<string, string> {
+  const handles = new Map<string, string>();
+
+  for (const user of users) {
+    const handle = user.attributes.public_handle?.trim();
+
+    if (handle) {
+      handles.set(user.id, `@${handle}`);
+    }
+  }
+
+  return handles;
+}

package/src/lib/client.ts

@@ -142,6 +142,12 @@ export class ClankmatesClient {
     );
   }
 
+  async listPublicUsersById(ids: string[]) {
+    const path = withRepeatedQuery(`${API_PREFIX}/public/users/by-id`, "ids[]", ids);
+
+    return this.requestCollection<UserAttributes>(path, {});
+  }
+
   async listChannels(input: { limit?: number; cursor?: string } = {}) {
     return this.requestCollection<ChannelAttributes>(
       withQuery(`${API_PREFIX}/channels`, {
@@ -814,3 +820,14 @@ function withQuery(
   const query = search.toString();
   return query ? `${path}?${query}` : path;
 }
+
+function withRepeatedQuery(path: string, key: string, values: string[]): string {
+  const search = new URLSearchParams();
+
+  for (const value of values) {
+    search.append(key, value);
+  }
+
+  const query = search.toString();
+  return query ? `${path}?${query}` : path;
+}

package/src/types/api.ts

@@ -44,7 +44,8 @@ export interface JsonApiDocument<TAttributes extends object> {
 export type AccessKeyScope = "master" | "read_only";
 
 export interface UserAttributes {
-  email: string;
+  email?: string;
+  public_profile_id?: string;
   public_handle?: string | null;
 }