@clankmates/cli 0.1.1 → 0.3.0

package/src/commands/channel.ts

@@ -1,14 +1,20 @@
 import {
   booleanFlag,
+  integerFlag,
   requiredPositional,
   requiredStringFlag,
   stringFlag,
   type ParsedArgs,
 } from "../lib/args";
-import { storeChannelToken } from "../lib/config";
+import { storeChannelToken, updateProfile } from "../lib/config";
 import { createCommandContext } from "../lib/context";
 import { CliError } from "../lib/errors";
 import { printJson, printValue, type Io } from "../lib/output";
+import type {
+  ChannelAttributes,
+  ChannelKeyAttributes,
+  ChannelKeyIssueResponse,
+} from "../types/api";
 
 const CHANNEL_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
 const CHANNEL_NAME_ERROR =
@@ -23,23 +29,12 @@ export async function runChannelCommand(
 
   switch (subcommand) {
     case "list": {
-      const response = await context.client.listChannels();
-      const rows = response.items.map((item) => ({
-        id: item.id,
-        name: item.attributes.name,
-        visibility: item.attributes.visibility,
-        description: item.attributes.description ?? "",
-      }));
-
-      if (context.outputMode === "json") {
-        printJson(io, {
-          items: response.items,
-          nextCursor: response.nextCursor,
-        });
-        return;
-      }
+      const response = await context.client.listChannels({
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
 
-      printValue(io, context.outputMode, rows);
+      printChannelCollection(context.outputMode, io, response);
       return;
     }
 
@@ -51,15 +46,45 @@ export async function runChannelCommand(
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json"
-          ? channel
-          : {
-              id: channel.id,
-              name: channel.attributes.name,
-              visibility: channel.attributes.visibility,
-              description: channel.attributes.description ?? "",
-              postingPausedUntil: channel.attributes.posting_paused_until ?? "",
-            },
+        context.outputMode === "json" ? channel : formatChannelRecord(channel),
+      );
+      return;
+    }
+
+    case "public-list": {
+      const response = await context.client.listPublicChannelsForHandle({
+        handle: requiredPositional(args.positionals, 1, "Missing public handle"),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printChannelCollection(context.outputMode, io, response);
+      return;
+    }
+
+    case "public-get": {
+      const channel = await context.client.getPublicChannelByHandle(
+        requiredPositional(args.positionals, 1, "Missing public handle"),
+        requiredPositional(args.positionals, 2, "Missing public channel name"),
+      );
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json" ? channel : formatChannelRecord(channel),
+      );
+      return;
+    }
+
+    case "shared-get": {
+      const channel = await context.client.getSharedChannel(
+        requiredPositional(args.positionals, 1, "Missing share token"),
+      );
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json" ? channel : formatChannelRecord(channel),
       );
       return;
     }
@@ -76,14 +101,7 @@ export async function runChannelCommand(
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json"
-          ? channel
-          : {
-              id: channel.id,
-              name: channel.attributes.name,
-              visibility: channel.attributes.visibility,
-              description: channel.attributes.description ?? "",
-            },
+        context.outputMode === "json" ? channel : formatChannelRecord(channel),
       );
       return;
     }
@@ -118,15 +136,57 @@ export async function runChannelCommand(
       printValue(
         io,
         context.outputMode,
-        context.outputMode === "json"
-          ? channel
-          : {
-              id: channel.id,
-              name: channel.attributes.name,
-              visibility: channel.attributes.visibility,
-              description: channel.attributes.description ?? "",
-            },
+        context.outputMode === "json" ? channel : formatChannelRecord(channel),
+      );
+      return;
+    }
+
+    case "publish-public": {
+      const channelId = await context.client.resolveChannelId(
+        requiredPositional(args.positionals, 1, "Missing channel"),
+      );
+      const channel = await context.client.publishChannelPublicly(channelId);
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json" ? channel : formatChannelRecord(channel),
+      );
+      return;
+    }
+
+    case "unpublish-public": {
+      const channelId = await context.client.resolveChannelId(
+        requiredPositional(args.positionals, 1, "Missing channel"),
+      );
+      const response = await context.client.unpublishChannelPublicly(channelId);
+
+      printValue(io, context.outputMode, response);
+      return;
+    }
+
+    case "share": {
+      const channelId = await context.client.resolveChannelId(
+        requiredPositional(args.positionals, 1, "Missing channel"),
+      );
+      const response = await context.client.shareChannel(channelId);
+
+      if (booleanFlag(args.flags, "tokenOnly")) {
+        io.stdout(response.token);
+        return;
+      }
+
+      printValue(io, context.outputMode, response);
+      return;
+    }
+
+    case "revoke-share": {
+      const channelId = await context.client.resolveChannelId(
+        requiredPositional(args.positionals, 1, "Missing channel"),
       );
+      const response = await context.client.revokeChannelShare(channelId);
+
+      printValue(io, context.outputMode, response);
       return;
     }
 
@@ -146,21 +206,93 @@ export async function runChannelCommand(
       return;
     }
 
+    case "token": {
+      await runChannelTokenCommand(args, io);
+      return;
+    }
+
     case "rotate-token": {
+      const channelRef = requiredPositional(args.positionals, 1, "Missing channel");
+      const channelId = await context.client.resolveChannelId(channelRef);
+      const response = await context.client.issueChannelKey({
+        channelId,
+        name: stringFlag(args.flags, "name") ?? legacyKeyName(),
+      });
+
+      await maybeStoreChannelToken(
+        args,
+        response,
+        channelId,
+        context.profileName,
+        context.configPath,
+      );
+
+      if (booleanFlag(args.flags, "tokenOnly")) {
+        io.stdout(response.token);
+        return;
+      }
+
+      printValue(io, context.outputMode, response);
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown channel subcommand", 2);
+  }
+}
+
+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, 1, "Missing channel"),
+        requiredPositional(args.positionals, 2, "Missing channel"),
       );
-      const response = await context.client.rotateChannelToken(channelId);
+      const response = await context.client.listChannelKeys({
+        channelId,
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
 
-      if (booleanFlag(args.flags, "save")) {
-        await storeChannelToken(
-          context.profileName,
-          channelId,
-          response.token,
-          context.configPath,
-        );
+      if (context.outputMode === "json") {
+        printJson(io, { items: response.items, nextCursor: response.nextCursor });
+        return;
       }
 
+      printValue(
+        io,
+        context.outputMode,
+        response.items.map((item) => formatChannelKeyRow(item)),
+      );
+      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;
@@ -170,9 +302,127 @@ export async function runChannelCommand(
       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, response);
+      return;
+    }
+
     default:
-      throw new CliError("Unknown channel subcommand", 2);
+      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);
+}
+
+function printChannelCollection(
+  outputMode: "json" | "table",
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: ChannelAttributes }>;
+    nextCursor?: string;
+  },
+): void {
+  if (outputMode === "json") {
+    printJson(io, {
+      items: response.items,
+      nextCursor: response.nextCursor,
+    });
+    return;
   }
+
+  printValue(
+    io,
+    outputMode,
+    response.items.map((item) => formatChannelRow(item)),
+  );
+}
+
+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 ?? "",
+    insertedAt: channel.attributes.inserted_at ?? "",
+    updatedAt: channel.attributes.updated_at ?? "",
+  };
+}
+
+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,
+    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 ?? "",
+  };
+}
+
+function legacyKeyName(): string {
+  return `legacy-rotate-${new Date().toISOString()}`;
+}
+
+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,
+  );
 }
 
 function assertValidChannelName(name: string): void {

package/src/commands/feed.ts

@@ -1,30 +1,70 @@
 import {
   channelFlag,
   integerFlag,
+  requiredPositional,
   stringFlag,
   type ParsedArgs,
 } from "../lib/args";
-import { createCommandContext } from "../lib/context";
+import { createCommandContext, type CommandContext } from "../lib/context";
 import { CliError } from "../lib/errors";
 import { printJson, printValue, type Io } from "../lib/output";
+import type { PostAttributes } from "../types/api";
 
 export async function runFeedCommand(args: ParsedArgs, io: Io): Promise<void> {
   const subcommand = args.positionals[0];
 
-  if (subcommand !== "my") {
-    throw new CliError("Unknown feed subcommand", 2);
+  switch (subcommand) {
+    case "my": {
+      const context = await createCommandContext(args, io);
+      const response = await context.client.myFeed({
+        channelId: await resolveChannelId(context, args),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printFeedResponse(context, io, response);
+      return;
+    }
+
+    case "search": {
+      const query = requiredPositional(
+        args.positionals,
+        1,
+        "Missing search query",
+      );
+      const context = await createCommandContext(args, io);
+      const response = await context.client.searchMyFeed({
+        query,
+        channelId: await resolveChannelId(context, args),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printFeedResponse(context, io, response);
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown feed subcommand", 2);
   }
+}
 
-  const context = await createCommandContext(args, io);
+async function resolveChannelId(
+  context: CommandContext,
+  args: ParsedArgs,
+): Promise<string | undefined> {
   const channel = channelFlag(args.flags);
-  const response = await context.client.myFeed({
-    channelId: channel
-      ? await context.client.resolveChannelId(channel)
-      : undefined,
-    limit: integerFlag(args.flags, "limit", { label: "--limit" }),
-    cursor: stringFlag(args.flags, "cursor"),
-  });
+  return channel ? context.client.resolveChannelId(channel) : undefined;
+}
 
+function printFeedResponse(
+  context: CommandContext,
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: PostAttributes }>;
+    nextCursor?: string;
+  },
+): void {
   if (context.outputMode === "json") {
     printJson(io, {
       items: response.items,

package/src/commands/post.ts

@@ -1,4 +1,5 @@
 import {
+  booleanFlag,
   integerFlag,
   requiredChannelFlag,
   requiredPositional,
@@ -9,6 +10,7 @@ import { resolveBodyInput } from "../lib/body-input";
 import { createCommandContext } from "../lib/context";
 import { CliError } from "../lib/errors";
 import { printJson, printValue, type Io } from "../lib/output";
+import type { PostAttributes } from "../types/api";
 
 export async function runPostCommand(args: ParsedArgs, io: Io): Promise<void> {
   const subcommand = args.positionals[0];
@@ -53,24 +55,34 @@ export async function runPostCommand(args: ParsedArgs, io: Io): Promise<void> {
         cursor: stringFlag(args.flags, "cursor"),
       });
 
-      if (context.outputMode === "json") {
-        printJson(io, {
-          items: response.items,
-          nextCursor: response.nextCursor,
-        });
-        return;
-      }
+      printPostCollection(context.outputMode, io, response);
+      return;
+    }
 
-      printValue(
-        io,
-        context.outputMode,
-        response.items.map((item) => ({
-          id: item.id,
-          source: item.attributes.source,
-          date: item.attributes.updated_at ?? item.attributes.inserted_at ?? "",
-          body: item.attributes.body,
-        })),
-      );
+    case "public-list": {
+      const response = await context.client.listPublicChannelPosts({
+        handle: requiredPositional(args.positionals, 1, "Missing public handle"),
+        channelName: requiredPositional(
+          args.positionals,
+          2,
+          "Missing public channel name",
+        ),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printPostCollection(context.outputMode, io, response);
+      return;
+    }
+
+    case "shared-list": {
+      const response = await context.client.listSharedChannelPosts({
+        token: requiredPositional(args.positionals, 1, "Missing share token"),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printPostCollection(context.outputMode, io, response);
       return;
     }
 
@@ -134,7 +146,102 @@ export async function runPostCommand(args: ParsedArgs, io: Io): Promise<void> {
       return;
     }
 
+    case "public-get": {
+      const post = await context.client.getPublicPostByHandle({
+        handle: requiredPositional(args.positionals, 1, "Missing public handle"),
+        channelName: requiredPositional(
+          args.positionals,
+          2,
+          "Missing public channel name",
+        ),
+        postId: requiredPositional(args.positionals, 3, "Missing post id"),
+      });
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? post
+          : {
+              id: post.id,
+              source: post.attributes.source,
+              body: post.attributes.body,
+            },
+      );
+      return;
+    }
+
+    case "shared-get": {
+      const post = await context.client.getSharedPost(
+        requiredPositional(args.positionals, 1, "Missing share token"),
+      );
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? post
+          : {
+              id: post.id,
+              source: post.attributes.source,
+              body: post.attributes.body,
+            },
+      );
+      return;
+    }
+
+    case "share": {
+      const response = await context.client.sharePost(
+        requiredPositional(args.positionals, 1, "Missing post id"),
+      );
+
+      if (booleanFlag(args.flags, "tokenOnly")) {
+        io.stdout(response.token);
+        return;
+      }
+
+      printValue(io, context.outputMode, response);
+      return;
+    }
+
+    case "revoke-share": {
+      const response = await context.client.revokePostShare(
+        requiredPositional(args.positionals, 1, "Missing post id"),
+      );
+
+      printValue(io, context.outputMode, response);
+      return;
+    }
+
     default:
       throw new CliError("Unknown post subcommand", 2);
   }
 }
+
+function printPostCollection(
+  outputMode: "json" | "table",
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: PostAttributes }>;
+    nextCursor?: string;
+  },
+): void {
+  if (outputMode === "json") {
+    printJson(io, {
+      items: response.items,
+      nextCursor: response.nextCursor,
+    });
+    return;
+  }
+
+  printValue(
+    io,
+    outputMode,
+    response.items.map((item) => ({
+      id: item.id,
+      source: item.attributes.source,
+      date: item.attributes.updated_at ?? item.attributes.inserted_at ?? "",
+      body: item.attributes.body,
+    })),
+  );
+}