@clankmates/cli 0.11.1 → 0.13.0

package/src/commands/channel/render.ts

@@ -0,0 +1,224 @@
+import {
+  joinBlocks,
+  renderFields,
+  renderPagination,
+  renderTokenAction,
+} from "../../lib/human";
+import { printJson, printValue, type Io } from "../../lib/output";
+import { paginatedJson, paginationInfo } from "../../lib/pagination";
+import type { ParsedArgs } from "../../lib/args";
+import type {
+  ChannelAttributes,
+  ChannelDiagnosticsResponse,
+  ChannelKeyAttributes,
+  ChannelKeyIssueResponse,
+  ChannelKeyRevokeResponse,
+  ChannelPinResponse,
+  ChannelPublicationResponse,
+  IdResponse,
+  ShareTokenResponse,
+} from "../../types/api";
+
+export function printChannelCollection(
+  args: ParsedArgs,
+  outputMode: "json" | "table",
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: ChannelAttributes }>;
+    nextCursor?: string;
+  },
+): void {
+  if (outputMode === "json") {
+    printJson(
+      io,
+      paginatedJson(args, {
+        items: response.items,
+        nextCursor: response.nextCursor,
+      }),
+    );
+    return;
+  }
+
+  printValue(
+    io,
+    outputMode,
+    response.items.map((item) => formatChannelRow(item)),
+  );
+  const pagination = paginationInfo(args, response.nextCursor);
+  const message = renderPagination(
+    pagination?.nextCursor,
+    pagination?.nextCommand,
+  );
+
+  if (message) {
+    io.stdout(message);
+  }
+}
+
+export function printChannelKeyCollection(
+  args: ParsedArgs,
+  outputMode: "json" | "table",
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: ChannelKeyAttributes }>;
+    nextCursor?: string;
+  },
+): void {
+  if (outputMode === "json") {
+    printJson(
+      io,
+      paginatedJson(args, {
+        items: response.items,
+        nextCursor: response.nextCursor,
+      }),
+    );
+    return;
+  }
+
+  printValue(
+    io,
+    outputMode,
+    response.items.map((item) => formatChannelKeyRow(item)),
+  );
+  const pagination = paginationInfo(args, response.nextCursor);
+  const message = renderPagination(
+    pagination?.nextCursor,
+    pagination?.nextCommand,
+  );
+
+  if (message) {
+    io.stdout(message);
+  }
+}
+
+export function formatChannelRecord(channel: {
+  id: string;
+  attributes: ChannelAttributes;
+}) {
+  return {
+    id: channel.id,
+    name: channel.attributes.name,
+    visibility: channel.attributes.visibility,
+    publiclyListed: channel.attributes.publicly_listed ?? false,
+    description: channel.attributes.description ?? "",
+    postingPausedUntil: channel.attributes.posting_paused_until ?? "",
+    pinnedPostId: channel.attributes.pinned_post_id ?? "",
+    insertedAt: channel.attributes.inserted_at ?? "",
+    updatedAt: channel.attributes.updated_at ?? "",
+  };
+}
+
+export function formatChannelDiagnostics(
+  diagnostics: ChannelDiagnosticsResponse,
+) {
+  return {
+    channelId: diagnostics.channel_id,
+    channelName: diagnostics.channel_name,
+    channelDescription: diagnostics.channel_description ?? "",
+    stateLabels: diagnostics.state_labels.join(", "),
+    activePublishKeyCount: diagnostics.active_publish_key_count,
+    lastPostedAt: diagnostics.last_posted_at ?? "",
+    postingPausedUntil: diagnostics.posting_paused_until ?? "",
+    latestBlockedWriteAt: diagnostics.latest_blocked_write_at ?? "",
+    latestBlockedWriteReason:
+      diagnostics.latest_blocked_write_reason_label ??
+      diagnostics.latest_blocked_write_reason ??
+      "",
+  };
+}
+
+export function renderShareToken(
+  title: string,
+  response: ShareTokenResponse,
+): string {
+  return joinBlocks([
+    title,
+    renderFields([["Token", response.token]]),
+  ]);
+}
+
+export function renderIdAction(title: string, response: IdResponse): string {
+  return joinBlocks([
+    title,
+    renderFields([["ID", response.id]]),
+  ]);
+}
+
+export function renderChannelPublicationAction(
+  title: string,
+  response: ChannelPublicationResponse,
+): string {
+  return joinBlocks([
+    title,
+    renderFields([
+      ["ID", response.id],
+      ["Name", response.name],
+      ["Publicly listed", response.publicly_listed],
+    ]),
+  ]);
+}
+
+export function renderChannelPinAction(
+  title: string,
+  response: ChannelPinResponse,
+): string {
+  const channel = Array.isArray(response.data)
+    ? response.data[0]
+    : response.data;
+
+  return joinBlocks([
+    title,
+    renderFields([
+      ["Channel", channel?.attributes.name ?? ""],
+      ["Pinned post", channel?.attributes.pinned_post_id ?? ""],
+    ]),
+  ]);
+}
+
+export function renderChannelKeyIssue(
+  title: string,
+  response: ChannelKeyIssueResponse,
+): string {
+  return renderTokenAction({
+    title,
+    id: response.id,
+    name: response.name,
+    token: response.token,
+    issuedAt: response.issued_at,
+    expiresAt: response.expires_at,
+  });
+}
+
+export function renderChannelKeyRevoke(
+  title: string,
+  response: ChannelKeyRevokeResponse,
+): string {
+  return joinBlocks([
+    title,
+    renderFields([
+      ["ID", response.id],
+      ["Name", response.name],
+    ]),
+  ]);
+}
+
+function formatChannelRow(channel: { id: string; attributes: ChannelAttributes }) {
+  return {
+    id: channel.id,
+    name: channel.attributes.name,
+    visibility: channel.attributes.visibility,
+    publiclyListed: channel.attributes.publicly_listed ?? false,
+    pinnedPostId: channel.attributes.pinned_post_id ?? "",
+    description: channel.attributes.description ?? "",
+  };
+}
+
+function formatChannelKeyRow(item: { id: string; attributes: ChannelKeyAttributes }) {
+  return {
+    id: item.id,
+    name: item.attributes.name ?? "",
+    expiresAt: item.attributes.expires_at ?? "",
+    revokedAt: item.attributes.revoked_at ?? "",
+    issuedAt: item.attributes.inserted_at ?? "",
+  };
+}

package/src/commands/channel/tokens.ts

@@ -0,0 +1,145 @@
+import {
+  booleanFlag,
+  integerFlag,
+  requiredPositional,
+  requiredStringFlag,
+  stringFlag,
+  type ParsedArgs,
+} from "../../lib/args";
+import { storeChannelToken, updateProfile } from "../../lib/config";
+import { createCommandContext } from "../../lib/context";
+import { CliError } from "../../lib/errors";
+import { printValue, type Io } from "../../lib/output";
+import type { ChannelKeyIssueResponse } from "../../types/api";
+import {
+  printChannelKeyCollection,
+  renderChannelKeyIssue,
+  renderChannelKeyRevoke,
+} from "./render";
+
+export async function runChannelTokenCommand(
+  args: ParsedArgs,
+  io: Io,
+): Promise<void> {
+  const context = await createCommandContext(args, io);
+  const tokenCommand = requiredPositional(
+    args.positionals,
+    1,
+    "Missing channel token subcommand",
+  );
+
+  switch (tokenCommand) {
+    case "list": {
+      const channelId = await context.client.resolveChannelId(
+        requiredPositional(args.positionals, 2, "Missing channel"),
+      );
+      const response = await context.client.listChannelKeys({
+        channelId,
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printChannelKeyCollection(args, context.outputMode, io, response);
+      return;
+    }
+
+    case "issue": {
+      const channelId = await context.client.resolveChannelId(
+        requiredPositional(args.positionals, 2, "Missing channel"),
+      );
+      const response = await context.client.issueChannelKey({
+        channelId,
+        name: requiredStringFlag(args.flags, "name"),
+      });
+
+      await maybeStoreChannelToken(
+        args,
+        response,
+        channelId,
+        context.profileName,
+        context.configPath,
+      );
+
+      if (booleanFlag(args.flags, "tokenOnly")) {
+        io.stdout(response.token);
+        return;
+      }
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? response
+          : renderChannelKeyIssue("Issued channel token", response),
+      );
+      return;
+    }
+
+    case "revoke": {
+      const response = await context.client.revokeChannelKey(
+        requiredPositional(args.positionals, 2, "Missing channel key id"),
+      );
+      await pruneInvalidStoredChannelTokens(
+        context.profileName,
+        context.profile.channelTokens,
+        context.client,
+        context.configPath,
+      );
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? response
+          : renderChannelKeyRevoke("Revoked channel token", response),
+      );
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown channel token subcommand", 2);
+  }
+}
+
+async function maybeStoreChannelToken(
+  args: ParsedArgs,
+  response: ChannelKeyIssueResponse,
+  channelId: string,
+  profileName: string,
+  configPath: string,
+): Promise<void> {
+  if (!booleanFlag(args.flags, "save")) {
+    return;
+  }
+
+  await storeChannelToken(profileName, channelId, response.token, configPath);
+}
+
+async function pruneInvalidStoredChannelTokens(
+  profileName: string,
+  storedTokens: Record<string, { token: string }>,
+  client: Awaited<ReturnType<typeof createCommandContext>>["client"],
+  configPath: string,
+): Promise<void> {
+  const invalidChannelIds: string[] = [];
+
+  for (const [channelId, storedToken] of Object.entries(storedTokens)) {
+    if (!(await client.canAuthenticate(storedToken.token))) {
+      invalidChannelIds.push(channelId);
+    }
+  }
+
+  if (invalidChannelIds.length === 0) {
+    return;
+  }
+
+  await updateProfile(
+    profileName,
+    (profile) => {
+      for (const channelId of invalidChannelIds) {
+        delete profile.channelTokens[channelId];
+      }
+    },
+    configPath,
+  );
+}

package/src/commands/channel/validation.ts

@@ -0,0 +1,11 @@
+import { CliError } from "../../lib/errors";
+
+const CHANNEL_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+const CHANNEL_NAME_ERROR =
+  "Channel names must start with a lowercase letter or digit and then use only lowercase letters, digits, hyphens, or underscores.";
+
+export function assertValidChannelName(name: string): void {
+  if (!CHANNEL_NAME_PATTERN.test(name)) {
+    throw new CliError(CHANNEL_NAME_ERROR, 2);
+  }
+}