@clankid/cli 0.17.0

package/src/commands/inbox.ts

@@ -0,0 +1,374 @@
+import {
+  assertSinceFlags,
+  cacheResult,
+  changeResponseMeta,
+} from "../lib/cache";
+import {
+  booleanFlag,
+  integerFlag,
+  requiredPositional,
+  stringFlag,
+  type ParsedArgs,
+} from "../lib/args";
+import { payloadFilters } from "../lib/content";
+import { createCommandContext, type CommandContext } from "../lib/context";
+import { CliError } from "../lib/errors";
+import { printValue, type Io } from "../lib/output";
+import { paginatedJson } from "../lib/pagination";
+import {
+  maybePrepareCachePlan,
+  maybeSaveCacheTimestamp,
+  parseLatestFirstOrder,
+  printChangeCheckResponse,
+  requiredSince,
+  resolvedSince,
+} from "../lib/polling";
+import { resolveMessageContent } from "./inbox/content";
+import {
+  parseMailboxFilter,
+  parseParticipantScope,
+  parseStatusFilter,
+} from "./inbox/filters";
+import {
+  parseRecipient,
+  resolveSender,
+} from "./inbox/participants";
+import {
+  ownerIdsForThreadDisplay,
+  publicUserHandlesById,
+  printThreadCollection,
+  renderAttachmentCollection,
+  renderThreadAction,
+  renderThreadWithMessages,
+} from "./inbox/render";
+import { runInboxMessagesCommand } from "./inbox/messages";
+import { runSchemaCommand } from "./inbox/schema";
+import { runScreeningCommand } from "./inbox/screening";
+import { maybeInboxMessagesScope, maybeInboxThreadsScope } from "./inbox/sync-scopes";
+import { runInboxWatchCommand } from "./inbox/watch";
+import type {
+  MailboxFilter,
+  ParticipantScope,
+  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 "list": {
+      const identityKey = stringFlag(args.flags, "identityKey");
+      assertSinceFlags(args);
+      const status = parseStatusFilter(stringFlag(args.flags, "status"));
+      const mailbox = parseMailboxFilter(stringFlag(args.flags, "mailbox"));
+      const participantScope = parseParticipantScope(
+        stringFlag(args.flags, "participantScope"),
+      );
+      const cacheScope = await maybeInboxThreadsScope(
+        args,
+        context,
+        identityKey,
+        status,
+        mailbox,
+        participantScope,
+      );
+      const cachePlan = await maybePrepareCachePlan(args, context, cacheScope);
+      const response = await context.client.listInboxThreads({
+        status,
+        mailbox,
+        ...payloadFilters(args),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+        before: stringFlag(args.flags, "before"),
+        order: parseLatestFirstOrder(stringFlag(args.flags, "order")),
+        since: resolvedSince(args, cachePlan),
+        participant: stringFlag(args.flags, "participant"),
+        participantScope,
+        query: stringFlag(args.flags, "query"),
+        hasAttachment: booleanFlag(args.flags, "hasAttachment") || undefined,
+        identityKey,
+      });
+      const savedServerTimestamp = await maybeSaveCacheTimestamp(
+        args,
+        context,
+        cacheScope,
+        response.meta,
+        response.nextCursor === undefined,
+      );
+
+      await printThreadCollection(
+        args,
+        context,
+        io,
+        response,
+        identityKey,
+        cacheResult(cachePlan, savedServerTimestamp),
+      );
+      return;
+    }
+
+    case "show": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const identityKey = stringFlag(args.flags, "identityKey");
+      assertSinceFlags(args);
+      const cacheScope = await maybeInboxMessagesScope(
+        args,
+        context,
+        identityKey,
+        threadId,
+      );
+      const cachePlan = await maybePrepareCachePlan(args, context, cacheScope);
+      const thread = await context.client.getThread(threadId, identityKey);
+      const messages = await context.client.listMessagesForThread({
+        threadId,
+        ...payloadFilters(args),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+        before: stringFlag(args.flags, "before"),
+        order: parseLatestFirstOrder(stringFlag(args.flags, "order")),
+        since: resolvedSince(args, cachePlan),
+        query: stringFlag(args.flags, "query"),
+        hasAttachment: booleanFlag(args.flags, "hasAttachment") || undefined,
+        identityKey,
+      });
+      const savedServerTimestamp = await maybeSaveCacheTimestamp(
+        args,
+        context,
+        cacheScope,
+        messages.meta,
+        messages.nextCursor === undefined,
+      );
+      const cache = cacheResult(cachePlan, savedServerTimestamp);
+      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,
+        context.outputMode,
+        context.outputMode === "json"
+          ? paginatedJson(args, {
+              thread,
+              messages: messages.items,
+              nextCursor: messages.nextCursor,
+              meta: messages.meta,
+              ...(cache ? { cache } : {}),
+            })
+          : renderThreadWithMessages(args, thread, messages, publicUsers, cache),
+      );
+      return;
+    }
+
+    case "changes": {
+      const identityKey = stringFlag(args.flags, "identityKey");
+      assertSinceFlags(args);
+      const status = parseStatusFilter(stringFlag(args.flags, "status"));
+      const mailbox = parseMailboxFilter(stringFlag(args.flags, "mailbox"));
+      const participantScope = parseParticipantScope(
+        stringFlag(args.flags, "participantScope"),
+      );
+      const cacheScope = await maybeInboxThreadsScope(
+        args,
+        context,
+        identityKey,
+        status,
+        mailbox,
+        participantScope,
+      );
+      const cachePlan = await maybePrepareCachePlan(args, context, cacheScope);
+      const response = await context.client.checkInboxThreadChanges({
+        since: requiredSince(args, cachePlan, "inbox thread"),
+        status,
+        mailbox,
+        ...payloadFilters(args),
+        participant: stringFlag(args.flags, "participant"),
+        participantScope,
+        query: stringFlag(args.flags, "query"),
+        hasAttachment: booleanFlag(args.flags, "hasAttachment") || undefined,
+        identityKey,
+      });
+      const savedServerTimestamp = await maybeSaveCacheTimestamp(
+        args,
+        context,
+        cacheScope,
+        changeResponseMeta(response),
+        response.has_updates === false,
+      );
+
+      printChangeCheckResponse(
+        context,
+        io,
+        response,
+        cacheResult(cachePlan, savedServerTimestamp),
+      );
+      return;
+    }
+
+    case "watch": {
+      await runInboxWatchCommand(context, args, io);
+      return;
+    }
+
+    case "messages": {
+      await runInboxMessagesCommand(context, args, io);
+      return;
+    }
+
+    case "attachments": {
+      const messageId = requiredPositional(args.positionals, 1, "Missing message id");
+      const response = await context.client.listMessageAttachments({
+        messageId,
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+        identityKey: stringFlag(args.flags, "identityKey"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? paginatedJson(args, {
+              items: response.items,
+              nextCursor: response.nextCursor,
+            })
+          : renderAttachmentCollection(args, response),
+      );
+      return;
+    }
+
+    case "screening": {
+      await runScreeningCommand(context, args, io);
+      return;
+    }
+
+    case "schema": {
+      await runSchemaCommand(context, args, io);
+      return;
+    }
+
+    case "send": {
+      const content = await resolveMessageContent(args);
+      const thread = await context.client.createThread({
+        recipient: await parseRecipient(
+          context,
+          requiredPositional(args.positionals, 1, "Missing recipient"),
+        ),
+        body: content.body,
+        payload: content.payload,
+        contentFormat: content.contentFormat,
+        from: await resolveSender(context, args),
+        contextPostId: stringFlag(args.flags, "contextPostId"),
+        identityKey: stringFlag(args.flags, "identityKey"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Created thread", thread),
+      );
+      return;
+    }
+
+    case "reply": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const identityKey = stringFlag(args.flags, "identityKey");
+      const content = await resolveMessageContent(args);
+      const thread = await context.client.appendThreadMessage({
+        threadId,
+        body: content.body,
+        payload: content.payload,
+        contentFormat: content.contentFormat,
+        from: await resolveSender(context, args),
+        contextPostId: stringFlag(args.flags, "contextPostId"),
+        identityKey,
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Replied to thread", thread),
+      );
+      return;
+    }
+
+    case "seen": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const thread = await context.client.markThreadSeen({
+        threadId,
+        identityKey: stringFlag(args.flags, "identityKey"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Marked thread as seen", thread),
+      );
+      return;
+    }
+
+    case "archive": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const thread = await context.client.archiveThread({
+        threadId,
+        identityKey: stringFlag(args.flags, "identityKey"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Archived thread", thread),
+      );
+      return;
+    }
+
+    case "resolve": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const thread = await context.client.resolveThread({
+        threadId,
+        identityKey: stringFlag(args.flags, "identityKey"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Resolved thread", thread),
+      );
+      return;
+    }
+
+    case "block": {
+      const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
+      const thread = await context.client.blockThread({
+        threadId,
+        identityKey: stringFlag(args.flags, "identityKey"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? thread
+          : renderThreadAction("Blocked thread", thread),
+      );
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown inbox subcommand", 2);
+  }
+}