@clankmates/cli 0.2.0 → 0.3.1

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,
+    })),
+  );
+}

package/src/commands/user.ts

@@ -0,0 +1,52 @@
+import { requiredPositional, type ParsedArgs } from "../lib/args";
+import { createCommandContext } from "../lib/context";
+import { CliError } from "../lib/errors";
+import { printValue, type Io } from "../lib/output";
+
+export async function runUserCommand(args: ParsedArgs, io: Io): Promise<void> {
+  const subcommand = args.positionals[0];
+  const context = await createCommandContext(args, io);
+
+  switch (subcommand) {
+    case "get": {
+      const user = await context.client.getUserByPublicHandle(
+        requiredPositional(args.positionals, 1, "Missing public handle"),
+      );
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? user
+          : {
+              id: user.id,
+              email: user.attributes.email,
+              publicHandle: user.attributes.public_handle ?? "",
+            },
+      );
+      return;
+    }
+
+    case "claim-handle": {
+      const user = await context.client.claimPublicHandle(
+        requiredPositional(args.positionals, 1, "Missing public handle"),
+      );
+
+      printValue(
+        io,
+        context.outputMode,
+        context.outputMode === "json"
+          ? user
+          : {
+              id: user.id,
+              email: user.attributes.email,
+              publicHandle: user.attributes.public_handle ?? "",
+            },
+      );
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown user subcommand", 2);
+  }
+}

package/src/lib/args.ts

@@ -15,6 +15,7 @@ const CLI_OPTIONS = {
   "master-token": { type: "string" },
   readOnlyToken: { type: "string" },
   "read-only-token": { type: "string" },
+  scope: { type: "string" },
   name: { type: "string" },
   description: { type: "string" },
   save: { type: "boolean" },

package/src/lib/client.ts

@@ -2,24 +2,48 @@ import { expectCollection, expectResource } from "./json_api";
 import { requestJson, requestJsonApi, type RequestOptions } from "./http";
 import { CliError } from "./errors";
 import {
-  requireOwnerReadToken,
   requireMasterToken,
+  requireOwnerReadToken,
   resolveChannelActorOrMasterToken,
   resolveMasterToken,
   resolveOwnerReadToken,
   resolvePublishToken,
 } from "./tokens";
 import type {
-  WhoamiResponse,
+  AccessKeyAttributes,
+  AccessKeyIssueResponse,
+  AccessKeyRevokeResponse,
+  AccessKeyScope,
   ChannelAttributes,
+  ChannelDiagnosticsResponse,
+  ChannelKeyAttributes,
+  ChannelKeyIssueResponse,
+  ChannelKeyRevokeResponse,
+  ChannelPublicationResponse,
+  IdResponse,
   PostAttributes,
   ProfileConfig,
-  RotateTokenResponse,
+  ShareTokenResponse,
+  UserAttributes,
+  WhoamiResponse,
 } from "../types/api";
 
 export class ClankmatesClient {
   constructor(private readonly profile: ProfileConfig) {}
 
+  async canAuthenticate(token: string): Promise<boolean> {
+    try {
+      await this.whoami(token);
+      return true;
+    } catch (error) {
+      if (isUnauthorizedCliError(error)) {
+        return false;
+      }
+
+      throw error;
+    }
+  }
+
   async validateMasterToken(token: string): Promise<void> {
     const response = await this.whoami(token);
 
@@ -54,12 +78,76 @@ export class ClankmatesClient {
     ).data;
   }
 
-  async listChannels() {
-    return this.requestCollection<ChannelAttributes>(`${API_PREFIX}/channels`, {
+  async listAccessKeys(scope?: AccessKeyScope) {
+    const path = scope
+      ? `${API_PREFIX}/me/access-keys/scopes/${encodeURIComponent(scope)}`
+      : `${API_PREFIX}/me/access-keys`;
+
+    return this.requestCollection<AccessKeyAttributes>(path, {
       token: requireOwnerReadToken(this.profile),
     });
   }
 
+  async issueAccessKey(input: { scope: AccessKeyScope; name: string }) {
+    return this.requestAction<AccessKeyIssueResponse>(
+      `${API_PREFIX}/me/access-keys`,
+      {
+        method: "POST",
+        token: requireMasterToken(this.profile),
+        body: {
+          data: {
+            scope: input.scope,
+            name: input.name,
+          },
+        },
+      },
+    );
+  }
+
+  async revokeAccessKey(id: string) {
+    return this.requestAction<AccessKeyRevokeResponse>(
+      `${API_PREFIX}/me/access-keys/${id}`,
+      {
+        method: "DELETE",
+        token: requireMasterToken(this.profile),
+      },
+    );
+  }
+
+  async claimPublicHandle(publicHandle: string) {
+    return this.requestResource<UserAttributes>(`${API_PREFIX}/me/public-handle`, {
+      method: "PATCH",
+      token: requireMasterToken(this.profile),
+      body: {
+        data: {
+          type: "user",
+          attributes: {
+            public_handle: publicHandle,
+          },
+        },
+      },
+    });
+  }
+
+  async getUserByPublicHandle(publicHandle: string) {
+    return this.requestResource<UserAttributes>(
+      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}`,
+      {},
+    );
+  }
+
+  async listChannels(input: { limit?: number; cursor?: string } = {}) {
+    return this.requestCollection<ChannelAttributes>(
+      withQuery(`${API_PREFIX}/channels`, {
+        "page[limit]": input.limit,
+        "page[after]": input.cursor,
+      }),
+      {
+        token: requireOwnerReadToken(this.profile),
+      },
+    );
+  }
+
   async getChannel(channelId: string) {
     return this.requestResource<ChannelAttributes>(
       `${API_PREFIX}/channels/${channelId}`,
@@ -69,6 +157,15 @@ export class ClankmatesClient {
     );
   }
 
+  async getChannelDiagnostics(channelId: string) {
+    return this.requestAction<ChannelDiagnosticsResponse>(
+      `${API_PREFIX}/channels/${channelId}/diagnostics`,
+      {
+        token: requireOwnerReadToken(this.profile),
+      },
+    );
+  }
+
   async getChannelByName(channelName: string) {
     return this.requestResource<ChannelAttributes>(
       `${API_PREFIX}/channels/by-name/${encodeURIComponent(channelName)}`,
@@ -78,6 +175,37 @@ export class ClankmatesClient {
     );
   }
 
+  async getPublicChannelByHandle(handle: string, name: string) {
+    return this.requestResource<ChannelAttributes>(
+      `${API_PREFIX}/public/users/${encodeURIComponent(handle)}/channels/${encodeURIComponent(name)}`,
+      {},
+    );
+  }
+
+  async listPublicChannelsForHandle(input: {
+    handle: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return this.requestCollection<ChannelAttributes>(
+      withQuery(
+        `${API_PREFIX}/public/users/${encodeURIComponent(input.handle)}/channels`,
+        {
+          "page[limit]": input.limit,
+          "page[after]": input.cursor,
+        },
+      ),
+      {},
+    );
+  }
+
+  async getSharedChannel(token: string) {
+    return this.requestResource<ChannelAttributes>(
+      `${API_PREFIX}/shares/channels/${encodeURIComponent(token)}`,
+      {},
+    );
+  }
+
   async createChannel(input: { name: string; description?: string }) {
     return this.requestResource<ChannelAttributes>(`${API_PREFIX}/channels`, {
       method: "POST",
@@ -120,6 +248,50 @@ export class ClankmatesClient {
     );
   }
 
+  async publishChannelPublicly(channelId: string) {
+    return this.requestResource<ChannelAttributes>(
+      `${API_PREFIX}/channels/${channelId}/publication`,
+      {
+        method: "PATCH",
+        token: requireMasterToken(this.profile),
+        body: {
+          data: {
+            type: "channel",
+            id: channelId,
+          },
+        },
+      },
+    );
+  }
+
+  async unpublishChannelPublicly(channelId: string) {
+    return this.requestAction<ChannelPublicationResponse>(
+      `${API_PREFIX}/channels/${channelId}/publication`,
+      {
+        method: "DELETE",
+        token: requireMasterToken(this.profile),
+      },
+    );
+  }
+
+  async shareChannel(channelId: string) {
+    return this.requestAction<ShareTokenResponse>(
+      `${API_PREFIX}/channels/${channelId}/share`,
+      {
+        method: "POST",
+        token: requireMasterToken(this.profile),
+        body: { data: {} },
+      },
+    );
+  }
+
+  async revokeChannelShare(channelId: string) {
+    return this.requestAction<IdResponse>(`${API_PREFIX}/channels/${channelId}/share`, {
+      method: "DELETE",
+      token: requireMasterToken(this.profile),
+    });
+  }
+
   async deleteChannel(channelId: string): Promise<void> {
     await this.requestJsonApi(`${API_PREFIX}/channels/${channelId}`, {
       method: "DELETE",
@@ -127,17 +299,45 @@ export class ClankmatesClient {
     });
   }
 
-  async rotateChannelToken(channelId: string): Promise<RotateTokenResponse> {
-    return (
-      await this.requestJsonApi<RotateTokenResponse>(
-        `${API_PREFIX}/channels/${channelId}/token/rotate`,
-        {
-          method: "POST",
-          token: requireMasterToken(this.profile),
-          body: {},
+  async listChannelKeys(input: {
+    channelId: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return this.requestCollection<ChannelKeyAttributes>(
+      withQuery(`${API_PREFIX}/channels/${input.channelId}/tokens`, {
+        "page[limit]": input.limit,
+        "page[after]": input.cursor,
+      }),
+      {
+        token: requireOwnerReadToken(this.profile),
+      },
+    );
+  }
+
+  async issueChannelKey(input: { channelId: string; name: string }) {
+    return this.requestAction<ChannelKeyIssueResponse>(
+      `${API_PREFIX}/channels/${input.channelId}/tokens`,
+      {
+        method: "POST",
+        token: requireMasterToken(this.profile),
+        body: {
+          data: {
+            name: input.name,
+          },
         },
-      )
-    ).data;
+      },
+    );
+  }
+
+  async revokeChannelKey(id: string) {
+    return this.requestAction<ChannelKeyRevokeResponse>(
+      `${API_PREFIX}/channel-keys/${id}`,
+      {
+        method: "DELETE",
+        token: requireMasterToken(this.profile),
+      },
+    );
   }
 
   async publishPost(input: {
@@ -190,6 +390,38 @@ export class ClankmatesClient {
     );
   }
 
+  async listPublicChannelPosts(input: {
+    handle: string;
+    channelName: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return this.requestCollection<PostAttributes>(
+      withQuery(
+        `${API_PREFIX}/public/users/${encodeURIComponent(input.handle)}/channels/${encodeURIComponent(input.channelName)}/posts`,
+        {
+          "page[limit]": input.limit,
+          "page[after]": input.cursor,
+        },
+      ),
+      {},
+    );
+  }
+
+  async listSharedChannelPosts(input: {
+    token: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return this.requestCollection<PostAttributes>(
+      withQuery(`${API_PREFIX}/shares/channels/${encodeURIComponent(input.token)}/posts`, {
+        "page[limit]": input.limit,
+        "page[after]": input.cursor,
+      }),
+      {},
+    );
+  }
+
   async getPost(postId: string) {
     return this.requestResource<PostAttributes>(
       `${API_PREFIX}/posts/${postId}`,
@@ -199,6 +431,24 @@ export class ClankmatesClient {
     );
   }
 
+  async getPublicPostByHandle(input: {
+    handle: string;
+    channelName: string;
+    postId: string;
+  }) {
+    return this.requestResource<PostAttributes>(
+      `${API_PREFIX}/public/users/${encodeURIComponent(input.handle)}/channels/${encodeURIComponent(input.channelName)}/posts/${input.postId}`,
+      {},
+    );
+  }
+
+  async getSharedPost(token: string) {
+    return this.requestResource<PostAttributes>(
+      `${API_PREFIX}/shares/posts/${encodeURIComponent(token)}`,
+      {},
+    );
+  }
+
   async editPost(input: {
     postId: string;
     body: string;
@@ -236,6 +486,21 @@ export class ClankmatesClient {
     });
   }
 
+  async sharePost(postId: string) {
+    return this.requestAction<ShareTokenResponse>(`${API_PREFIX}/posts/${postId}/share`, {
+      method: "POST",
+      token: requireMasterToken(this.profile),
+      body: { data: {} },
+    });
+  }
+
+  async revokePostShare(postId: string) {
+    return this.requestAction<IdResponse>(`${API_PREFIX}/posts/${postId}/share`, {
+      method: "DELETE",
+      token: requireMasterToken(this.profile),
+    });
+  }
+
   async myFeed(input: { channelId?: string; limit?: number; cursor?: string }) {
     return this.requestCollection<PostAttributes>(
       withQuery(`${API_PREFIX}/feeds/my`, {
@@ -291,6 +556,28 @@ export class ClankmatesClient {
     ).data;
   }
 
+  async resolveChannelId(channel: string): Promise<string> {
+    if (looksLikeUuid(channel)) {
+      return channel;
+    }
+
+    return (await this.resolveOwnedChannel(channel)).id;
+  }
+
+  async resolveOwnedChannel(channel: string) {
+    if (looksLikeUuid(channel)) {
+      return this.getChannel(channel);
+    }
+
+    if (!resolveOwnerReadToken(this.profile).token) {
+      throw new CliError(
+        `Resolving channel name "${channel}" requires an owner read token. Use the channel UUID or configure a read-only or master token.`,
+      );
+    }
+
+    return this.getChannelByName(channel);
+  }
+
   private async requestResource<TAttributes extends object>(
     path: string,
     options: RequestOptions,
@@ -309,33 +596,18 @@ export class ClankmatesClient {
     );
   }
 
-  private async requestJsonApi<T = unknown>(
+  private async requestAction<T = unknown>(
     path: string,
     options: RequestOptions = {},
   ) {
-    return requestJsonApi<T>(this.profile.baseUrl, path, options);
-  }
-
-  async resolveChannelId(channel: string): Promise<string> {
-    if (looksLikeUuid(channel)) {
-      return channel;
-    }
-
-    return (await this.resolveOwnedChannel(channel)).id;
+    return (await this.requestJsonApi<T>(path, options)).data;
   }
 
-  async resolveOwnedChannel(channel: string) {
-    if (looksLikeUuid(channel)) {
-      return this.getChannel(channel);
-    }
-
-    if (!resolveOwnerReadToken(this.profile).token) {
-      throw new CliError(
-        `Resolving channel name "${channel}" requires an owner read token. Use the channel UUID or configure a read-only or master token.`,
-      );
-    }
-
-    return this.getChannelByName(channel);
+  private async requestJsonApi<T = unknown>(
+    path: string,
+    options: RequestOptions = {},
+  ) {
+    return requestJsonApi<T>(this.profile.baseUrl, path, options);
   }
 
   private resolvePostLifecycleToken(explicitToken?: string): string {
@@ -364,6 +636,15 @@ function inferMediaType(path: string): string {
     : "application/vnd.api+json";
 }
 
+function isUnauthorizedCliError(error: unknown): boolean {
+  return (
+    error instanceof CliError &&
+    error.exitCode === 1 &&
+    (error.message.includes("Authentication required") ||
+      error.message.includes("code=unauthorized"))
+  );
+}
+
 function isPlainJsonPath(path: string): boolean {
   return (
     path === `${API_PREFIX}/open_api` || path.startsWith(`${API_PREFIX}/auth/`)