@clankmates/cli 0.11.1 → 0.13.0

package/src/lib/client.ts

@@ -1,865 +1,394 @@
-import { expectCollection, expectResource } from "./json_api";
-import { requestJson, requestJsonApi, type RequestOptions } from "./http";
-import { CliError } from "./errors";
-import {
-  requireMasterToken,
-  requireOwnerReadToken,
-  resolveChannelActorOrMasterToken,
-  resolveMasterToken,
-  resolveOwnerReadToken,
-  resolvePublishToken,
-} from "./tokens";
+import { ApiClientCore } from "./client/core";
+import * as auth from "./client/auth";
+import * as channelKeys from "./client/channel-keys";
+import * as channels from "./client/channels";
+import * as feed from "./client/feed";
+import * as inbox from "./client/inbox";
+import * as posts from "./client/posts";
+import * as rawApi from "./client/raw-api";
+import * as users from "./client/users";
 import type {
-  AccessKeyAttributes,
-  AccessKeyIssueResponse,
-  AccessKeyRevokeResponse,
   AccessKeyScope,
-  ChannelAttributes,
-  ChannelDiagnosticsResponse,
-  ChannelKeyAttributes,
-  ChannelKeyIssueResponse,
-  ChannelKeyRevokeResponse,
-  ChannelPinResponse,
-  ChannelPublicationResponse,
-  ChangeCheckResponse,
   ExternalEmailAcceptance,
-  ExternalEmailIntakeAttributes,
   InboxRecipient,
   InboxSender,
-  IdResponse,
   LatestFirstOrder,
   MailboxFilter,
-  MessageAttachmentAttributes,
-  MessageAttributes,
-  PostAttributes,
+  ParticipantScope,
   ProfileConfig,
-  ShareTokenResponse,
-  ThreadAttributes,
   ThreadStatusFilter,
-  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);
-
-    if (
-      response.actor.type !== "user" ||
-      response.actor.scope === "read_only"
-    ) {
-      throw new CliError("Provided token is not a master token.");
-    }
-  }
-
-  async validateReadOnlyToken(token: string): Promise<void> {
-    const response = await this.whoami(token);
-
-    if (
-      response.actor.type !== "user" ||
-      response.actor.scope !== "read_only"
-    ) {
-      throw new CliError("Provided token is not a read-only token.");
-    }
-  }
-
-  async whoami(
-    token = requireOwnerReadToken(this.profile),
-  ): Promise<WhoamiResponse> {
-    return (
-      await requestJson<WhoamiResponse>(
-        this.profile.baseUrl,
-        `${API_PREFIX}/auth/whoami`,
-        { token },
-      )
-    ).data;
-  }
-
-  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,
-          },
-        },
-      },
-    );
+  private readonly core: ApiClientCore;
+
+  constructor(profile: ProfileConfig) {
+    this.core = new ApiClientCore(profile);
   }
 
-  async revokeAccessKey(id: string) {
-    return this.requestAction<AccessKeyRevokeResponse>(
-      `${API_PREFIX}/me/access-keys/${id}`,
-      {
-        method: "DELETE",
-        token: requireMasterToken(this.profile),
-      },
-    );
+  canAuthenticate(token: string): Promise<boolean> {
+    return auth.canAuthenticate(this.core, token);
   }
 
-  async getUserByPublicHandle(publicHandle: string) {
-    return this.requestResource<UserAttributes>(
-      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}`,
-      {},
-    );
+  validateMasterToken(token: string): Promise<void> {
+    return auth.validateMasterToken(this.core, token);
   }
 
-  async getPublicAccountInboxSchema(publicHandle: string) {
-    return this.requestResource<UserAttributes>(
-      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/inbox-schema`,
-      {},
-    );
+  validateReadOnlyToken(token: string): Promise<void> {
+    return auth.validateReadOnlyToken(this.core, token);
   }
 
-  async setAccountInboxSchema(inboxSchema: Record<string, unknown>) {
-    return this.requestResource<UserAttributes>(`${API_PREFIX}/me/inbox-schema`, {
-      method: "PATCH",
-      token: requireMasterToken(this.profile),
-      body: {
-        data: {
-          type: "user",
-          attributes: {
-            inbox_schema: inboxSchema,
-          },
-        },
-      },
-    });
-  }
-
-  async removeAccountInboxSchema() {
-    return this.requestResource<UserAttributes>(
-      `${API_PREFIX}/me/inbox-schema/remove`,
-      {
-        method: "PATCH",
-        token: requireMasterToken(this.profile),
-        body: {
-          data: {
-            type: "user",
-            attributes: {},
-          },
-        },
-      },
-    );
+  whoami(token?: string) {
+    return auth.whoami(this.core, token);
+  }
+
+  listAccessKeys(scope?: AccessKeyScope) {
+    return auth.listAccessKeys(this.core, scope);
+  }
+
+  issueAccessKey(input: { scope: AccessKeyScope; name: string }) {
+    return auth.issueAccessKey(this.core, input);
+  }
+
+  revokeAccessKey(id: string) {
+    return auth.revokeAccessKey(this.core, id);
+  }
+
+  getUserByPublicHandle(publicHandle: string) {
+    return users.getUserByPublicHandle(this.core, publicHandle);
+  }
+
+  getPublicAccountInboxSchema(publicHandle: string) {
+    return users.getPublicAccountInboxSchema(this.core, publicHandle);
   }
 
-  async setAccountExternalEmailAcceptance(
+  setAccountInboxSchema(inboxSchema: Record<string, unknown>) {
+    return users.setAccountInboxSchema(this.core, inboxSchema);
+  }
+
+  removeAccountInboxSchema() {
+    return users.removeAccountInboxSchema(this.core);
+  }
+
+  setAccountExternalEmailAcceptance(
     externalEmailAcceptance: ExternalEmailAcceptance,
   ) {
-    return this.requestResource<UserAttributes>(`${API_PREFIX}/me/inbox-acceptance`, {
-      method: "PATCH",
-      token: requireMasterToken(this.profile),
-      body: {
-        data: {
-          type: "user",
-          attributes: {
-            external_email_acceptance: externalEmailAcceptance,
-          },
-        },
-      },
-    });
-  }
-
-  async listPublicUsersById(ids: string[]) {
-    const path = withRepeatedQuery(`${API_PREFIX}/public/users/by-id`, "ids[]", ids);
-
-    return this.requestCollection<UserAttributes>(path, {});
-  }
-
-  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),
-      },
+    return users.setAccountExternalEmailAcceptance(
+      this.core,
+      externalEmailAcceptance,
     );
   }
 
-  async getChannel(channelId: string) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/channels/${channelId}`,
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+  listPublicUsersById(ids: string[]) {
+    return users.listPublicUsersById(this.core, ids);
   }
 
-  async getChannelDiagnostics(channelId: string) {
-    return this.requestAction<ChannelDiagnosticsResponse>(
-      `${API_PREFIX}/channels/${channelId}/diagnostics`,
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+  listChannels(input: { limit?: number; cursor?: string } = {}) {
+    return channels.listChannels(this.core, input);
   }
 
-  async getChannelByName(channelName: string) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/channels/by-name/${encodeURIComponent(channelName)}`,
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+  getChannel(channelId: string) {
+    return channels.getChannel(this.core, channelId);
   }
 
-  async getPublicChannelByHandle(publicHandle: string, name: string) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/channels/${encodeURIComponent(name)}`,
-      {},
-    );
+  getChannelDiagnostics(channelId: string) {
+    return channels.getChannelDiagnostics(this.core, channelId);
   }
 
-  async getPublicChannelInboxSchema(publicHandle: string, name: string) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/channels/${encodeURIComponent(name)}/inbox-schema`,
-      {},
-    );
+  getChannelByName(channelName: string) {
+    return channels.getChannelByName(this.core, channelName);
+  }
+
+  getPublicChannelByHandle(publicHandle: string, name: string) {
+    return channels.getPublicChannelByHandle(this.core, publicHandle, name);
   }
 
-  async listPublicChannelsForHandle(input: {
+  getPublicChannelInboxSchema(publicHandle: string, name: string) {
+    return channels.getPublicChannelInboxSchema(this.core, publicHandle, name);
+  }
+
+  listPublicChannelsForHandle(input: {
     publicHandle: string;
     limit?: number;
     cursor?: string;
   }) {
-    return this.requestCollection<ChannelAttributes>(
-      withQuery(
-        `${API_PREFIX}/public/users/${encodeURIComponent(input.publicHandle)}/channels`,
-        {
-          "page[limit]": input.limit,
-          "page[after]": input.cursor,
-        },
-      ),
-      {},
-    );
+    return channels.listPublicChannelsForHandle(this.core, input);
   }
 
-  async getSharedChannel(token: string) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/shares/channels/${encodeURIComponent(token)}`,
-      {},
-    );
+  getSharedChannel(token: string) {
+    return channels.getSharedChannel(this.core, token);
   }
 
-  async createChannel(input: { name: string; description?: string }) {
-    return this.requestResource<ChannelAttributes>(`${API_PREFIX}/channels`, {
-      method: "POST",
-      token: requireMasterToken(this.profile),
-      body: {
-        data: {
-          type: "channel",
-          attributes: {
-            name: input.name,
-            ...(input.description ? { description: input.description } : {}),
-          },
-        },
-      },
-    });
+  createChannel(input: { name: string; description?: string }) {
+    return channels.createChannel(this.core, input);
   }
 
-  async updateChannel(input: {
+  updateChannel(input: {
     channelId: string;
     name?: string;
     description?: string;
   }) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/channels/${input.channelId}`,
-      {
-        method: "PATCH",
-        token: requireMasterToken(this.profile),
-        body: {
-          data: {
-            type: "channel",
-            id: input.channelId,
-            attributes: {
-              ...(input.name !== undefined ? { name: input.name } : {}),
-              ...(input.description !== undefined
-                ? { description: input.description }
-                : {}),
-            },
-          },
-        },
-      },
-    );
+    return channels.updateChannel(this.core, input);
   }
 
-  async setChannelInboxSchema(input: {
+  setChannelInboxSchema(input: {
     channelId: string;
     inboxSchema: Record<string, unknown>;
   }) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/channels/${input.channelId}/inbox-schema`,
-      {
-        method: "PATCH",
-        token: requireMasterToken(this.profile),
-        body: {
-          data: {
-            type: "channel",
-            id: input.channelId,
-            attributes: {
-              inbox_schema: input.inboxSchema,
-            },
-          },
-        },
-      },
-    );
+    return channels.setChannelInboxSchema(this.core, input);
   }
 
-  async removeChannelInboxSchema(channelId: string) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/channels/${channelId}/inbox-schema/remove`,
-      {
-        method: "PATCH",
-        token: requireMasterToken(this.profile),
-        body: {
-          data: {
-            type: "channel",
-            id: channelId,
-            attributes: {},
-          },
-        },
-      },
-    );
+  removeChannelInboxSchema(channelId: string) {
+    return channels.removeChannelInboxSchema(this.core, channelId);
   }
 
-  async setChannelExternalEmailAcceptance(input: {
+  setChannelExternalEmailAcceptance(input: {
     channelId: string;
     externalEmailAcceptance: ExternalEmailAcceptance;
   }) {
-    return this.requestResource<ChannelAttributes>(
-      `${API_PREFIX}/channels/${input.channelId}/inbox-acceptance`,
-      {
-        method: "PATCH",
-        token: requireMasterToken(this.profile),
-        body: {
-          data: {
-            type: "channel",
-            id: input.channelId,
-            attributes: {
-              external_email_acceptance: input.externalEmailAcceptance,
-            },
-          },
-        },
-      },
-    );
+    return channels.setChannelExternalEmailAcceptance(this.core, input);
   }
 
-  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,
-          },
-        },
-      },
-    );
+  publishChannelPublicly(channelId: string) {
+    return channels.publishChannelPublicly(this.core, channelId);
   }
 
-  async unpublishChannelPublicly(channelId: string) {
-    return this.requestAction<ChannelPublicationResponse>(
-      `${API_PREFIX}/channels/${channelId}/publication`,
-      {
-        method: "DELETE",
-        token: requireMasterToken(this.profile),
-      },
-    );
+  unpublishChannelPublicly(channelId: string) {
+    return channels.unpublishChannelPublicly(this.core, channelId);
   }
 
-  async shareChannel(channelId: string) {
-    return this.requestAction<ShareTokenResponse>(
-      `${API_PREFIX}/channels/${channelId}/share`,
-      {
-        method: "POST",
-        token: requireMasterToken(this.profile),
-        body: { data: {} },
-      },
-    );
+  shareChannel(channelId: string) {
+    return channels.shareChannel(this.core, channelId);
   }
 
-  async revokeChannelShare(channelId: string) {
-    return this.requestAction<IdResponse>(`${API_PREFIX}/channels/${channelId}/share`, {
-      method: "DELETE",
-      token: requireMasterToken(this.profile),
-    });
+  revokeChannelShare(channelId: string) {
+    return channels.revokeChannelShare(this.core, channelId);
   }
 
-  async pinChannelPost(input: {
+  pinChannelPost(input: {
     channelId: string;
     postId: string;
     channelToken?: string;
   }) {
-    return this.requestAction<ChannelPinResponse>(
-      `${API_PREFIX}/channels/${input.channelId}/pinned-post`,
-      {
-        method: "POST",
-        token: this.resolveChannelConfigToken(input.channelId, input.channelToken),
-        body: {
-          data: {
-            attributes: {
-              post_id: input.postId,
-            },
-          },
-        },
-      },
-    );
+    return channels.pinChannelPost(this.core, input);
   }
 
-  async unpinChannelPost(input: { channelId: string; channelToken?: string }) {
-    return this.requestAction<ChannelPinResponse>(
-      `${API_PREFIX}/channels/${input.channelId}/pinned-post`,
-      {
-        method: "DELETE",
-        token: this.resolveChannelConfigToken(input.channelId, input.channelToken),
-      },
-    );
+  unpinChannelPost(input: { channelId: string; channelToken?: string }) {
+    return channels.unpinChannelPost(this.core, input);
   }
 
-  async deleteChannel(channelId: string): Promise<void> {
-    await this.requestJsonApi(`${API_PREFIX}/channels/${channelId}`, {
-      method: "DELETE",
-      token: requireMasterToken(this.profile),
-    });
+  deleteChannel(channelId: string): Promise<void> {
+    return channels.deleteChannel(this.core, channelId);
   }
 
-  async listChannelKeys(input: {
+  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),
-      },
-    );
+    return channelKeys.listChannelKeys(this.core, input);
   }
 
-  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,
-          },
-        },
-      },
-    );
+  issueChannelKey(input: { channelId: string; name: string }) {
+    return channelKeys.issueChannelKey(this.core, input);
   }
 
-  async revokeChannelKey(id: string) {
-    return this.requestAction<ChannelKeyRevokeResponse>(
-      `${API_PREFIX}/channel-keys/${id}`,
-      {
-        method: "DELETE",
-        token: requireMasterToken(this.profile),
-      },
-    );
+  revokeChannelKey(id: string) {
+    return channelKeys.revokeChannelKey(this.core, id);
   }
 
-  async publishPost(input: {
+  publishPost(input: {
     channelId: string;
     body: string;
     channelToken?: string;
   }) {
-    const resolved = resolvePublishToken(
-      this.profile,
-      input.channelId,
-      input.channelToken,
-    );
-
-    if (!resolved.token) {
-      throw new CliError(
-        `No publish token available for channel ${input.channelId}. Provide --channel-token, set channel token env vars, save a channel token, or configure a master token.`,
-      );
-    }
-
-    return this.requestResource<PostAttributes>(
-      `${API_PREFIX}/channels/${input.channelId}/posts`,
-      {
-        method: "POST",
-        token: resolved.token,
-        body: {
-          data: {
-            type: "post",
-            attributes: {
-              body: input.body,
-            },
-          },
-        },
-      },
-    );
+    return posts.publishPost(this.core, input);
   }
 
-  async listChannelPosts(input: {
+  listChannelPosts(input: {
     channelId: string;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
   }) {
-    return this.requestCollection<PostAttributes>(
-      withQuery(`${API_PREFIX}/channels/${input.channelId}/posts`, {
-        order: input.order,
-        since: input.since,
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+    return posts.listChannelPosts(this.core, input);
   }
 
-  async listPublicChannelPosts(input: {
+  listPublicChannelPosts(input: {
     publicHandle: string;
     channelName: string;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
   }) {
-    return this.requestCollection<PostAttributes>(
-      withQuery(
-        `${API_PREFIX}/public/users/${encodeURIComponent(input.publicHandle)}/channels/${encodeURIComponent(input.channelName)}/posts`,
-        {
-          order: input.order,
-          since: input.since,
-          "page[limit]": input.limit,
-          "page[after]": input.cursor,
-        },
-      ),
-      {},
-    );
+    return posts.listPublicChannelPosts(this.core, input);
   }
 
-  async listSharedChannelPosts(input: {
+  listSharedChannelPosts(input: {
     token: string;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
   }) {
-    return this.requestCollection<PostAttributes>(
-      withQuery(`${API_PREFIX}/shares/channels/${encodeURIComponent(input.token)}/posts`, {
-        order: input.order,
-        since: input.since,
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {},
-    );
+    return posts.listSharedChannelPosts(this.core, input);
   }
 
-  async getPost(postId: string) {
-    return this.requestResource<PostAttributes>(
-      `${API_PREFIX}/posts/${postId}`,
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+  getPost(postId: string) {
+    return posts.getPost(this.core, postId);
   }
 
-  async getPublicPostByHandle(input: {
+  getPublicPostByHandle(input: {
     publicHandle: string;
     channelName: string;
     postId: string;
   }) {
-    return this.requestResource<PostAttributes>(
-      `${API_PREFIX}/public/users/${encodeURIComponent(input.publicHandle)}/channels/${encodeURIComponent(input.channelName)}/posts/${input.postId}`,
-      {},
-    );
+    return posts.getPublicPostByHandle(this.core, input);
   }
 
-  async getSharedPost(token: string) {
-    return this.requestResource<PostAttributes>(
-      `${API_PREFIX}/shares/posts/${encodeURIComponent(token)}`,
-      {},
-    );
+  getSharedPost(token: string) {
+    return posts.getSharedPost(this.core, token);
   }
 
-  async editPost(input: {
+  editPost(input: {
     postId: string;
     body: string;
     channelToken?: string;
   }) {
-    const token = this.resolvePostLifecycleToken(input.channelToken);
-
-    return this.requestResource<PostAttributes>(
-      `${API_PREFIX}/posts/${input.postId}`,
-      {
-        method: "PATCH",
-        token,
-        body: {
-          data: {
-            type: "post",
-            id: input.postId,
-            attributes: {
-              body: input.body,
-            },
-          },
-        },
-      },
-    );
+    return posts.editPost(this.core, input);
   }
 
-  async deletePost(input: {
+  deletePost(input: {
     postId: string;
     channelToken?: string;
   }): Promise<void> {
-    const token = this.resolvePostLifecycleToken(input.channelToken);
-
-    await this.requestJsonApi(`${API_PREFIX}/posts/${input.postId}`, {
-      method: "DELETE",
-      token,
-    });
+    return posts.deletePost(this.core, input);
   }
 
-  async sharePost(postId: string) {
-    return this.requestAction<ShareTokenResponse>(`${API_PREFIX}/posts/${postId}/share`, {
-      method: "POST",
-      token: requireMasterToken(this.profile),
-      body: { data: {} },
-    });
+  sharePost(postId: string) {
+    return posts.sharePost(this.core, postId);
   }
 
-  async revokePostShare(postId: string) {
-    return this.requestAction<IdResponse>(`${API_PREFIX}/posts/${postId}/share`, {
-      method: "DELETE",
-      token: requireMasterToken(this.profile),
-    });
+  revokePostShare(postId: string) {
+    return posts.revokePostShare(this.core, postId);
   }
 
-  async myFeed(input: {
+  myFeed(input: {
     channelId?: string;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
   }) {
-    return this.requestCollection<PostAttributes>(
-      withQuery(`${API_PREFIX}/feeds/my`, {
-        channel_id: input.channelId,
-        order: input.order,
-        since: input.since,
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+    return feed.myFeed(this.core, input);
   }
 
-  async searchMyFeed(input: {
+  searchMyFeed(input: {
     query: string;
     channelId?: string;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
   }) {
-    return this.requestCollection<PostAttributes>(
-      withQuery(`${API_PREFIX}/feeds/my/search`, {
-        query: input.query,
-        channel_id: input.channelId,
-        order: input.order,
-        since: input.since,
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+    return feed.searchMyFeed(this.core, input);
   }
 
-  async checkMyFeedChanges(input: { since: string; channelId?: string }) {
-    return this.requestAction<ChangeCheckResponse>(
-      withQuery(`${API_PREFIX}/feeds/my/changes`, {
-        since: input.since,
-        channel_id: input.channelId,
-      }),
-      {
-        token: requireOwnerReadToken(this.profile),
-      },
-    );
+  checkMyFeedChanges(input: { since: string; channelId?: string }) {
+    return feed.checkMyFeedChanges(this.core, input);
   }
 
-  async listInboxThreads(input: {
+  listInboxThreads(input: {
     status?: ThreadStatusFilter;
     mailbox?: MailboxFilter;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
+    participant?: string;
+    participantScope?: ParticipantScope;
+    query?: string;
+    hasAttachment?: boolean;
     channelToken?: string;
   } = {}) {
-    return this.requestCollection<ThreadAttributes>(
-      withQuery(`${API_PREFIX}/threads`, {
-        status: input.status,
-        mailbox: input.mailbox,
-        order: input.order,
-        since: input.since,
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.listInboxThreads(this.core, input);
   }
 
-  async checkInboxThreadChanges(input: {
+  checkInboxThreadChanges(input: {
     since: string;
     status?: ThreadStatusFilter;
     mailbox?: MailboxFilter;
+    participant?: string;
+    participantScope?: ParticipantScope;
+    query?: string;
+    hasAttachment?: boolean;
     channelToken?: string;
   }) {
-    return this.requestAction<ChangeCheckResponse>(
-      withQuery(`${API_PREFIX}/threads/changes`, {
-        since: input.since,
-        status: input.status,
-        mailbox: input.mailbox,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.checkInboxThreadChanges(this.core, input);
   }
 
-  async getThread(threadId: string, channelToken?: string) {
-    return this.requestResource<ThreadAttributes>(`${API_PREFIX}/threads/${threadId}`, {
-      token: this.resolveInboxReadToken(channelToken),
-    });
+  getThread(threadId: string, channelToken?: string) {
+    return inbox.getThread(this.core, threadId, channelToken);
   }
 
-  async listMessagesForThread(input: {
+  listMessagesForThread(input: {
     threadId: string;
     limit?: number;
     cursor?: string;
+    before?: string;
     order?: LatestFirstOrder;
     since?: string;
+    query?: string;
+    hasAttachment?: boolean;
     channelToken?: string;
   }) {
-    return this.requestCollection<MessageAttributes>(
-      withQuery(`${API_PREFIX}/threads/${input.threadId}/messages`, {
-        order: input.order,
-        since: input.since,
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.listMessagesForThread(this.core, input);
   }
 
-  async checkThreadMessageChanges(input: {
+  checkThreadMessageChanges(input: {
     threadId: string;
     since: string;
+    query?: string;
+    hasAttachment?: boolean;
     channelToken?: string;
   }) {
-    return this.requestAction<ChangeCheckResponse>(
-      withQuery(`${API_PREFIX}/threads/${input.threadId}/messages/changes`, {
-        since: input.since,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.checkThreadMessageChanges(this.core, input);
   }
 
-  async listMessageAttachments(input: {
+  listMessageAttachments(input: {
     messageId: string;
     limit?: number;
     cursor?: string;
     channelToken?: string;
   }) {
-    return this.requestCollection<MessageAttachmentAttributes>(
-      withQuery(`${API_PREFIX}/messages/${input.messageId}/attachments`, {
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.listMessageAttachments(this.core, input);
   }
 
-  async listEmailScreeningIntakes(input: {
+  listEmailScreeningIntakes(input: {
     limit?: number;
     cursor?: string;
     channelToken?: string;
   } = {}) {
-    return this.requestCollection<ExternalEmailIntakeAttributes>(
-      withQuery(`${API_PREFIX}/email-intakes/screening`, {
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.listEmailScreeningIntakes(this.core, input);
   }
 
-  async listEmailProcessingIntakes(input: {
+  listEmailProcessingIntakes(input: {
     limit?: number;
     cursor?: string;
     channelToken?: string;
   } = {}) {
-    return this.requestCollection<ExternalEmailIntakeAttributes>(
-      withQuery(`${API_PREFIX}/email-intakes/processing`, {
-        "page[limit]": input.limit,
-        "page[after]": input.cursor,
-      }),
-      {
-        token: this.resolveInboxReadToken(input.channelToken),
-      },
-    );
+    return inbox.listEmailProcessingIntakes(this.core, input);
   }
 
-  async createThread(input: {
+  createThread(input: {
     recipient: InboxRecipient;
     body?: string;
     payload?: Record<string, unknown>;
@@ -867,27 +396,10 @@ export class ClankmatesClient {
     contextPostId?: string;
     channelToken?: string;
   }) {
-    return this.requestResource<ThreadAttributes>(`${API_PREFIX}/threads`, {
-      method: "POST",
-      token: this.resolveInboxWriteToken(input.channelToken),
-      body: {
-        data: {
-          type: "thread",
-          attributes: {
-            recipient: input.recipient,
-            ...(input.body !== undefined ? { body: input.body } : {}),
-            ...(input.payload !== undefined ? { payload: input.payload } : {}),
-            ...(input.from ? { from: input.from } : {}),
-            ...(input.contextPostId
-              ? { context_post_id: input.contextPostId }
-              : {}),
-          },
-        },
-      },
-    });
-  }
-
-  async appendThreadMessage(input: {
+    return inbox.createThread(this.core, input);
+  }
+
+  appendThreadMessage(input: {
     threadId: string;
     body?: string;
     payload?: Record<string, unknown>;
@@ -895,264 +407,55 @@ export class ClankmatesClient {
     contextPostId?: string;
     channelToken?: string;
   }) {
-    return this.requestResource<ThreadAttributes>(
-      `${API_PREFIX}/threads/${input.threadId}/messages`,
-      {
-        method: "POST",
-        token: this.resolveInboxWriteToken(input.channelToken),
-        body: {
-          data: {
-            type: "thread",
-            attributes: {
-              ...(input.body !== undefined ? { body: input.body } : {}),
-              ...(input.payload !== undefined ? { payload: input.payload } : {}),
-              ...(input.from ? { from: input.from } : {}),
-              ...(input.contextPostId
-                ? { context_post_id: input.contextPostId }
-                : {}),
-            },
-          },
-        },
-      },
-    );
+    return inbox.appendThreadMessage(this.core, input);
   }
 
-  async markThreadSeen(input: { threadId: string; channelToken?: string }) {
-    return this.updateThreadLifecycle(`${API_PREFIX}/threads/${input.threadId}/seen`, input);
+  markThreadSeen(input: { threadId: string; channelToken?: string }) {
+    return inbox.markThreadSeen(this.core, input);
   }
 
-  async archiveThread(input: { threadId: string; channelToken?: string }) {
-    return this.updateThreadLifecycle(`${API_PREFIX}/threads/${input.threadId}/archive`, input);
+  archiveThread(input: { threadId: string; channelToken?: string }) {
+    return inbox.archiveThread(this.core, input);
   }
 
-  async resolveThread(input: { threadId: string; channelToken?: string }) {
-    return this.updateThreadLifecycle(`${API_PREFIX}/threads/${input.threadId}/resolve`, input);
+  resolveThread(input: { threadId: string; channelToken?: string }) {
+    return inbox.resolveThread(this.core, input);
   }
 
-  async blockThread(input: { threadId: string; channelToken?: string }) {
-    return this.updateThreadLifecycle(`${API_PREFIX}/threads/${input.threadId}/block`, input);
+  blockThread(input: { threadId: string; channelToken?: string }) {
+    return inbox.blockThread(this.core, input);
   }
 
-  async approveEmailIntake(input: { intakeId: string; channelToken?: string }) {
-    return this.updateEmailIntake(
-      `${API_PREFIX}/email-intakes/${input.intakeId}/approve`,
-      input,
-    );
+  approveEmailIntake(input: { intakeId: string; channelToken?: string }) {
+    return inbox.approveEmailIntake(this.core, input);
   }
 
-  async approveEmailIntakeOnce(input: { intakeId: string; channelToken?: string }) {
-    return this.updateEmailIntake(
-      `${API_PREFIX}/email-intakes/${input.intakeId}/approve-once`,
-      input,
-    );
+  approveEmailIntakeOnce(input: { intakeId: string; channelToken?: string }) {
+    return inbox.approveEmailIntakeOnce(this.core, input);
   }
 
-  async ignoreEmailIntake(input: { intakeId: string; channelToken?: string }) {
-    return this.updateEmailIntake(
-      `${API_PREFIX}/email-intakes/${input.intakeId}/ignore`,
-      input,
-    );
+  ignoreEmailIntake(input: { intakeId: string; channelToken?: string }) {
+    return inbox.ignoreEmailIntake(this.core, input);
   }
 
-  async fetchOpenApi(): Promise<unknown> {
-    return (await requestJson(this.profile.baseUrl, `${API_PREFIX}/open_api`))
-      .data;
+  fetchOpenApi(): Promise<unknown> {
+    return rawApi.fetchOpenApi(this.core);
   }
 
-  async apiRequest(input: {
+  apiRequest(input: {
     method: string;
     path: string;
     body?: string;
     channelToken?: string;
   }): Promise<unknown> {
-    return (
-      await requestJson(this.profile.baseUrl, input.path, {
-        method: input.method,
-        token: input.channelToken ?? resolveMasterToken(this.profile).token,
-        rawBody: input.body,
-        accept: inferMediaType(input.path),
-        contentType:
-          input.body === undefined ? undefined : inferMediaType(input.path),
-      })
-    ).data;
+    return rawApi.apiRequest(this.core, input);
   }
 
-  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);
+  resolveChannelId(channel: string): Promise<string> {
+    return channels.resolveChannelId(this.core, channel);
   }
 
-  private async requestResource<TAttributes extends object>(
-    path: string,
-    options: RequestOptions,
-  ) {
-    return expectResource<TAttributes>(
-      (await this.requestJsonApi(path, options)).data,
-    );
+  resolveOwnedChannel(channel: string) {
+    return channels.resolveOwnedChannel(this.core, channel);
   }
-
-  private async requestCollection<TAttributes extends object>(
-    path: string,
-    options: RequestOptions,
-  ) {
-    return expectCollection<TAttributes>(
-      (await this.requestJsonApi(path, options)).data,
-    );
-  }
-
-  private async requestAction<T = unknown>(
-    path: string,
-    options: RequestOptions = {},
-  ) {
-    return (await this.requestJsonApi<T>(path, options)).data;
-  }
-
-  private async requestJsonApi<T = unknown>(
-    path: string,
-    options: RequestOptions = {},
-  ) {
-    return requestJsonApi<T>(this.profile.baseUrl, path, options);
-  }
-
-  private resolvePostLifecycleToken(explicitToken?: string): string {
-    const resolved = resolveChannelActorOrMasterToken(
-      this.profile,
-      explicitToken,
-    );
-
-    if (!resolved.token) {
-      throw new CliError(
-        "No token available for post edit/delete. Provide --channel-token, set CLANKMATES_CHANNEL_TOKEN, configure a single saved channel token, or configure a master token.",
-      );
-    }
-
-    return resolved.token;
-  }
-
-  private resolveChannelConfigToken(channelId: string, explicitToken?: string): string {
-    const resolved = resolvePublishToken(this.profile, channelId, explicitToken);
-
-    if (!resolved.token) {
-      throw new CliError(
-        "No token available for channel configuration. Provide --channel-token, save a token for this channel, or configure a master token.",
-      );
-    }
-
-    return resolved.token;
-  }
-
-  private resolveInboxReadToken(explicitToken?: string): string {
-    return explicitToken ?? requireOwnerReadToken(this.profile);
-  }
-
-  private resolveInboxWriteToken(explicitToken?: string): string {
-    return explicitToken ?? requireMasterToken(this.profile);
-  }
-
-  private async updateThreadLifecycle(
-    path: string,
-    input: { threadId: string; channelToken?: string },
-  ) {
-    return this.requestResource<ThreadAttributes>(path, {
-      method: "PATCH",
-      token: this.resolveInboxWriteToken(input.channelToken),
-      body: {
-        data: {
-          type: "thread",
-          id: input.threadId,
-          attributes: {},
-        },
-      },
-    });
-  }
-
-  private async updateEmailIntake(
-    path: string,
-    input: { intakeId: string; channelToken?: string },
-  ) {
-    return this.requestResource<ExternalEmailIntakeAttributes>(path, {
-      method: "PATCH",
-      token: this.resolveInboxWriteToken(input.channelToken),
-      body: {
-        data: {
-          type: "external_email_intake",
-          id: input.intakeId,
-          attributes: {},
-        },
-      },
-    });
-  }
-}
-
-const API_PREFIX = "/api/v1";
-const UUID_PATTERN =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-
-function inferMediaType(path: string): string {
-  return isPlainJsonPath(path)
-    ? "application/json"
-    : "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/`)
-  );
-}
-
-function looksLikeUuid(value: string): boolean {
-  return UUID_PATTERN.test(value);
-}
-
-function withQuery(
-  path: string,
-  params: Record<string, string | number | undefined>,
-): string {
-  const search = new URLSearchParams();
-
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== undefined) {
-      search.set(key, String(value));
-    }
-  }
-
-  const query = search.toString();
-  return query ? `${path}?${query}` : path;
-}
-
-function withRepeatedQuery(path: string, key: string, values: string[]): string {
-  const search = new URLSearchParams();
-
-  for (const value of values) {
-    search.append(key, value);
-  }
-
-  const query = search.toString();
-  return query ? `${path}?${query}` : path;
 }