@clankmates/cli 0.11.1 → 0.13.0

package/src/commands/inbox/resource-output.ts

@@ -0,0 +1,217 @@
+import type { ParsedArgs } from "../../lib/args";
+import type { CommandContext } from "../../lib/context";
+import {
+  formatTimestamp,
+  indent,
+  joinBlocks,
+  renderFields,
+  renderPagination,
+  renderSection,
+  shortId,
+} from "../../lib/human";
+import { printValue, type Io } from "../../lib/output";
+import { paginatedJson, paginationInfo } from "../../lib/pagination";
+import type {
+  ExternalEmailAcceptance,
+  ExternalEmailIntakeAttributes,
+  MessageAttachmentAttributes,
+} from "../../types/api";
+
+export function printSchemaResource(
+  context: CommandContext,
+  io: Io,
+  resource: {
+    id: string;
+    attributes: {
+      public_handle?: string | null;
+      name?: string | null;
+      inbox_schema?: Record<string, unknown> | null;
+      inbox_schema_hash?: string | null;
+      inbox_schema_updated_at?: string | null;
+      external_email_acceptance?: ExternalEmailAcceptance | null;
+    };
+  },
+  action?: string,
+): void {
+  printValue(
+    io,
+    context.outputMode,
+    context.outputMode === "json"
+      ? resource
+      : renderSchemaResource(resource, action),
+  );
+}
+
+export function printEmailIntakeCollection(
+  args: ParsedArgs,
+  context: CommandContext,
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: ExternalEmailIntakeAttributes }>;
+    nextCursor?: string;
+  },
+): void {
+  printValue(
+    io,
+    context.outputMode,
+    context.outputMode === "json"
+      ? paginatedJson(args, {
+          items: response.items,
+          nextCursor: response.nextCursor,
+        })
+      : renderEmailIntakeCollection(args, response),
+  );
+}
+
+export function printEmailIntakeAction(
+  context: CommandContext,
+  io: Io,
+  action: string,
+  intake: { id: string; attributes: ExternalEmailIntakeAttributes },
+): void {
+  printValue(
+    io,
+    context.outputMode,
+    context.outputMode === "json"
+      ? intake
+      : joinBlocks([`${action}: ${intake.id}`, renderEmailIntake(intake)]),
+  );
+}
+
+export function renderAttachmentCollection(
+  args: ParsedArgs,
+  response: {
+    items: Array<{ id: string; attributes: MessageAttachmentAttributes }>;
+    nextCursor?: string;
+  },
+): string {
+  const body =
+    response.items.length === 0
+      ? "No attachments."
+      : response.items
+          .map((attachment) => {
+            const attrs = attachment.attributes;
+
+            return joinBlocks([
+              `Attachment ${attachment.id}`,
+              renderFields([
+                ["Name", attrs.name ?? ""],
+                ["Content type", attrs.content_type ?? ""],
+                ["Content length", formatOptionalNumber(attrs.content_length)],
+                ["Message", formatActor("message", attrs.message_id)],
+              ]),
+            ]);
+          })
+          .join("\n\n");
+
+  const pagination = paginationInfo(args, response.nextCursor);
+  return joinBlocks([
+    body,
+    renderPagination(pagination?.nextCursor, pagination?.nextCommand),
+  ]);
+}
+
+function renderSchemaResource(
+  resource: {
+    id: string;
+    attributes: {
+      public_handle?: string | null;
+      name?: string | null;
+      inbox_schema?: Record<string, unknown> | null;
+      inbox_schema_hash?: string | null;
+      inbox_schema_updated_at?: string | null;
+      external_email_acceptance?: ExternalEmailAcceptance | null;
+    };
+  },
+  action?: string,
+): string {
+  const attrs = resource.attributes;
+  const schema = attrs.inbox_schema
+    ? JSON.stringify(attrs.inbox_schema, null, 2)
+    : "No inbox schema.";
+
+  return joinBlocks([
+    action,
+    `Inbox schema ${resource.id}`,
+    renderFields([
+      ["Handle", attrs.public_handle],
+      ["Channel", attrs.name],
+      ["Email acceptance", attrs.external_email_acceptance],
+      ["Hash", attrs.inbox_schema_hash],
+      ["Updated", formatTimestamp(attrs.inbox_schema_updated_at)],
+    ]),
+    renderSection("Schema", indent(schema)),
+  ]);
+}
+
+function renderEmailIntakeCollection(
+  args: ParsedArgs,
+  response: {
+    items: Array<{ id: string; attributes: ExternalEmailIntakeAttributes }>;
+    nextCursor?: string;
+  },
+): string {
+  const body =
+    response.items.length === 0
+      ? "No email intakes."
+      : response.items.map((intake) => renderEmailIntake(intake)).join("\n\n");
+
+  const pagination = paginationInfo(args, response.nextCursor);
+  return joinBlocks([
+    body,
+    renderPagination(pagination?.nextCursor, pagination?.nextCommand),
+  ]);
+}
+
+function renderEmailIntake(intake: {
+  id: string;
+  attributes: ExternalEmailIntakeAttributes;
+}): string {
+  const attrs = intake.attributes;
+
+  return joinBlocks([
+    `Email intake ${intake.id}`,
+    renderFields([
+      ["Subject", attrs.subject ?? ""],
+      ["Status", attrs.status ?? ""],
+      ["Decision", attrs.decision ?? ""],
+      ["Sender", formatActor("email-sender", attrs.external_email_sender_id)],
+      ["Target channel", formatActor("channel", attrs.target_channel_id)],
+      ["Raw recipient", attrs.raw_recipient ?? ""],
+      ["Received count", formatOptionalNumber(attrs.received_count)],
+      ["Attachment count", formatOptionalNumber(attrs.attachment_count)],
+      ["Attachments withheld", formatOptionalBoolean(attrs.attachments_withheld)],
+      ["Last received", formatTimestamp(attrs.last_received_at)],
+      ["Released", formatTimestamp(attrs.released_at)],
+      ["Released thread", formatActor("thread", attrs.released_thread_id)],
+    ]),
+    attrs.body ? renderSection("Body", indent(attrs.body)) : "",
+  ]);
+}
+
+function formatActor(
+  kind: "channel" | "email-sender" | "thread" | "message",
+  id?: string | null,
+): string {
+  if (!id) {
+    return "-";
+  }
+
+  return `${kind}:${shortId(id)}`;
+}
+
+function formatOptionalBoolean(value?: boolean | null): string {
+  if (value === undefined || value === null) {
+    return "";
+  }
+
+  return value ? "yes" : "no";
+}
+
+function formatOptionalNumber(value?: number | null): string {
+  if (value === undefined || value === null) {
+    return "";
+  }
+
+  return String(value);
+}

package/src/commands/inbox/schema.ts

@@ -0,0 +1,185 @@
+import { requiredPositional, type ParsedArgs } from "../../lib/args";
+import type { CommandContext } from "../../lib/context";
+import { CliError } from "../../lib/errors";
+import { resolveJsonInput } from "../../lib/json-input";
+import type { Io } from "../../lib/output";
+import { parseExternalEmailAcceptance } from "./filters";
+import { getPublicInboxSchema } from "./participants";
+import { printSchemaResource } from "./render";
+
+export async function runSchemaCommand(
+  context: CommandContext,
+  args: ParsedArgs,
+  io: Io,
+): Promise<void> {
+  const subcommand = args.positionals[1];
+
+  switch (subcommand) {
+    case "show": {
+      const target = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema target",
+      );
+      const schema = await getPublicInboxSchema(context, target);
+      printSchemaResource(context, io, schema);
+      return;
+    }
+
+    case "set": {
+      const scope = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema scope",
+      );
+      const inboxSchema = await requiredInboxSchema(args);
+
+      if (scope === "account") {
+        printSchemaResource(
+          context,
+          io,
+          await context.client.setAccountInboxSchema(inboxSchema),
+          "Updated account inbox schema",
+        );
+        return;
+      }
+
+      if (scope === "channel") {
+        const channelRef = requiredPositional(
+          args.positionals,
+          3,
+          "Missing channel name or id",
+        );
+        const channelId = await context.client.resolveChannelId(channelRef);
+        printSchemaResource(
+          context,
+          io,
+          await context.client.setChannelInboxSchema({
+            channelId,
+            inboxSchema,
+          }),
+          "Updated channel inbox schema",
+        );
+        return;
+      }
+
+      throw new CliError("Schema scope must be `account` or `channel`", 2);
+    }
+
+    case "remove": {
+      const scope = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema scope",
+      );
+
+      if (scope === "account") {
+        printSchemaResource(
+          context,
+          io,
+          await context.client.removeAccountInboxSchema(),
+          "Removed account inbox schema",
+        );
+        return;
+      }
+
+      if (scope === "channel") {
+        const channelRef = requiredPositional(
+          args.positionals,
+          3,
+          "Missing channel name or id",
+        );
+        const channelId = await context.client.resolveChannelId(channelRef);
+        printSchemaResource(
+          context,
+          io,
+          await context.client.removeChannelInboxSchema(channelId),
+          "Removed channel inbox schema",
+        );
+        return;
+      }
+
+      throw new CliError("Schema scope must be `account` or `channel`", 2);
+    }
+
+    case "acceptance": {
+      const scope = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema acceptance scope",
+      );
+
+      if (scope === "account") {
+        const externalEmailAcceptance = parseExternalEmailAcceptance(
+          requiredPositional(
+            args.positionals,
+            3,
+            "Missing external email acceptance policy",
+          ),
+        );
+
+        printSchemaResource(
+          context,
+          io,
+          await context.client.setAccountExternalEmailAcceptance(
+            externalEmailAcceptance,
+          ),
+          "Updated account inbox acceptance",
+        );
+        return;
+      }
+
+      if (scope === "channel") {
+        const channelRef = requiredPositional(
+          args.positionals,
+          3,
+          "Missing channel name or id",
+        );
+        const externalEmailAcceptance = parseExternalEmailAcceptance(
+          requiredPositional(
+            args.positionals,
+            4,
+            "Missing external email acceptance policy",
+          ),
+        );
+        const channelId = await context.client.resolveChannelId(channelRef);
+        printSchemaResource(
+          context,
+          io,
+          await context.client.setChannelExternalEmailAcceptance({
+            channelId,
+            externalEmailAcceptance,
+          }),
+          "Updated channel inbox acceptance",
+        );
+        return;
+      }
+
+      throw new CliError("Schema acceptance scope must be `account` or `channel`", 2);
+    }
+
+    default:
+      throw new CliError("Unknown inbox schema subcommand", 2);
+  }
+}
+
+async function requiredInboxSchema(
+  args: ParsedArgs,
+): Promise<Record<string, unknown>> {
+  const schema = await resolveJsonInput({
+    flags: args.flags,
+    inlineKey: "schema",
+    fileKey: "schemaFile",
+    stdinKey: "schemaStdin",
+    label: "Inbox schema",
+  });
+
+  if (!schema) {
+    throw new CliError(
+      "Provide exactly one of `--schema`, `--schema-file`, or `--schema-stdin`",
+      2,
+    );
+  }
+
+  return schema;
+}

package/src/commands/inbox/screening.ts

@@ -0,0 +1,76 @@
+import {
+  integerFlag,
+  requiredPositional,
+  stringFlag,
+  type ParsedArgs,
+} from "../../lib/args";
+import type { CommandContext } from "../../lib/context";
+import { CliError } from "../../lib/errors";
+import type { Io } from "../../lib/output";
+import { printEmailIntakeAction, printEmailIntakeCollection } from "./render";
+
+export async function runScreeningCommand(
+  context: CommandContext,
+  args: ParsedArgs,
+  io: Io,
+): Promise<void> {
+  const subcommand = args.positionals[1];
+  const channelToken = stringFlag(args.flags, "channelToken");
+
+  switch (subcommand) {
+    case "list": {
+      const response = await context.client.listEmailScreeningIntakes({
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+        channelToken,
+      });
+
+      printEmailIntakeCollection(args, context, io, response);
+      return;
+    }
+
+    case "processing": {
+      const response = await context.client.listEmailProcessingIntakes({
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+        channelToken,
+      });
+
+      printEmailIntakeCollection(args, context, io, response);
+      return;
+    }
+
+    case "approve": {
+      const intake = await context.client.approveEmailIntake({
+        intakeId: requiredPositional(args.positionals, 2, "Missing intake id"),
+        channelToken,
+      });
+
+      printEmailIntakeAction(context, io, "Approved email intake", intake);
+      return;
+    }
+
+    case "approve-once": {
+      const intake = await context.client.approveEmailIntakeOnce({
+        intakeId: requiredPositional(args.positionals, 2, "Missing intake id"),
+        channelToken,
+      });
+
+      printEmailIntakeAction(context, io, "Approved email intake once", intake);
+      return;
+    }
+
+    case "ignore": {
+      const intake = await context.client.ignoreEmailIntake({
+        intakeId: requiredPositional(args.positionals, 2, "Missing intake id"),
+        channelToken,
+      });
+
+      printEmailIntakeAction(context, io, "Ignored email intake", intake);
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown inbox screening subcommand", 2);
+  }
+}

package/src/commands/inbox/sync-scopes.ts

@@ -0,0 +1,59 @@
+import {
+  authenticatedActorKey,
+  cacheFlags,
+  inboxMessagesScope,
+  inboxThreadsScope,
+  type CacheScope,
+} from "../../lib/cache";
+import { booleanFlag, stringFlag, type ParsedArgs } from "../../lib/args";
+import type { CommandContext } from "../../lib/context";
+import type {
+  MailboxFilter,
+  ParticipantScope,
+  ThreadStatusFilter,
+} from "../../types/api";
+
+export async function maybeInboxThreadsScope(
+  args: ParsedArgs,
+  context: CommandContext,
+  channelToken: string | undefined,
+  status: ThreadStatusFilter | undefined,
+  mailbox: MailboxFilter | undefined,
+  participantScope: ParticipantScope | undefined,
+): Promise<CacheScope | undefined> {
+  if (!cacheFlags(args).sinceCache && !cacheFlags(args).saveCache) {
+    return undefined;
+  }
+
+  return inboxThreadsScope({
+    context,
+    actorKey: await authenticatedActorKey(context, channelToken),
+    status,
+    mailbox,
+    participant: stringFlag(args.flags, "participant"),
+    participantScope,
+    query: stringFlag(args.flags, "query"),
+    hasAttachment: booleanFlag(args.flags, "hasAttachment") || undefined,
+    before: stringFlag(args.flags, "before"),
+  });
+}
+
+export async function maybeInboxMessagesScope(
+  args: ParsedArgs,
+  context: CommandContext,
+  channelToken: string | undefined,
+  threadId: string,
+): Promise<CacheScope | undefined> {
+  if (!cacheFlags(args).sinceCache && !cacheFlags(args).saveCache) {
+    return undefined;
+  }
+
+  return inboxMessagesScope({
+    context,
+    actorKey: await authenticatedActorKey(context, channelToken),
+    threadId,
+    query: stringFlag(args.flags, "query"),
+    hasAttachment: booleanFlag(args.flags, "hasAttachment") || undefined,
+    before: stringFlag(args.flags, "before"),
+  });
+}