@bruch/max-client 0.1.0

package/src/api/chats.ts

@@ -0,0 +1,234 @@
+import { TsMaxError } from "../errors.ts";
+import { Opcode } from "../protocol/index.ts";
+import { Chat, Message, asRecord, type ChatActions, type MaxId } from "../types/index.ts";
+import { listItem, payload, payloadItem } from "./response.ts";
+import type { ApiRuntime } from "./runtime.ts";
+
+export interface GroupSettings {
+  allCanPinMessage?: boolean | null;
+  onlyOwnerCanChangeIconTitle?: boolean | null;
+  onlyAdminCanAddMember?: boolean | null;
+  onlyAdminCanCall?: boolean | null;
+  membersCanSeePrivateLink?: boolean | null;
+}
+
+export class ChatApi implements ChatActions {
+  private readonly cache = new Map<MaxId, Chat>();
+
+  constructor(private readonly app: ApiRuntime) {}
+
+  seed(chats: Chat[]): void {
+    for (const chat of chats) this.cache.set(chat.id, this.app.bindChat(chat));
+  }
+
+  async createGroup(
+    name: string,
+    participantIds: MaxId[] = [],
+    notify = true,
+  ): Promise<[Chat, Message] | null> {
+    const frame = await this.app.invoke(Opcode.MSG_SEND, {
+      message: {
+        cid: BigInt(Date.now()),
+        attaches: [
+          {
+            _type: "CONTROL",
+            event: "new",
+            chatType: "CHAT",
+            title: name,
+            userIds: participantIds,
+          },
+        ],
+      },
+      notify,
+    });
+    const chatRaw = payloadItem(frame, "chat");
+    if (!chatRaw) return null;
+    const chat = this.cacheChat(Chat.fromPayload(chatRaw));
+    const data = payload(frame);
+    const message = this.app.bindMessage(Message.fromPayload(data.message ?? data));
+    return [chat, message];
+  }
+
+  async inviteUsersToGroup(
+    chatId: MaxId,
+    userIds: MaxId[],
+    showHistory = true,
+  ): Promise<Chat | null> {
+    return await this.memberAction(chatId, userIds, "add", showHistory);
+  }
+
+  async inviteUsersToChannel(
+    chatId: MaxId,
+    userIds: MaxId[],
+    showHistory = true,
+  ): Promise<Chat | null> {
+    return await this.inviteUsersToGroup(chatId, userIds, showHistory);
+  }
+
+  async removeUsersFromGroup(
+    chatId: MaxId,
+    userIds: MaxId[],
+    cleanMsgPeriod = 0,
+  ): Promise<Chat | null> {
+    const frame = await this.app.invoke(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId,
+      userIds,
+      operation: "remove",
+      cleanMsgPeriod,
+    });
+    return this.optionalChat(payloadItem(frame, "chat"));
+  }
+
+  async changeGroupSettings(chatId: MaxId, settings: GroupSettings): Promise<void> {
+    const options: Record<string, boolean> = {};
+    const keys: Array<[keyof GroupSettings, string]> = [
+      ["allCanPinMessage", "ALL_CAN_PIN_MESSAGE"],
+      ["onlyOwnerCanChangeIconTitle", "ONLY_OWNER_CAN_CHANGE_ICON_TITLE"],
+      ["onlyAdminCanAddMember", "ONLY_ADMIN_CAN_ADD_MEMBER"],
+      ["onlyAdminCanCall", "ONLY_ADMIN_CAN_CALL"],
+      ["membersCanSeePrivateLink", "MEMBERS_CAN_SEE_PRIVATE_LINK"],
+    ];
+    for (const [source, target] of keys) {
+      const value = settings[source];
+      if (typeof value === "boolean") options[target] = value;
+    }
+    const frame = await this.app.invoke(Opcode.CHAT_UPDATE, { chatId, options });
+    this.optionalChat(payloadItem(frame, "chat"));
+  }
+
+  async changeGroupProfile(
+    chatId: MaxId,
+    name: string | null,
+    description: string | null = null,
+  ): Promise<void> {
+    const frame = await this.app.invoke(Opcode.CHAT_UPDATE, { chatId, theme: name, description });
+    this.optionalChat(payloadItem(frame, "chat"));
+  }
+
+  async joinGroup(link: string): Promise<Chat> {
+    const processed = processJoinLink(link);
+    if (!processed) throw new TypeError("Invalid group link");
+    return await this.join(processed);
+  }
+
+  async joinChannel(link: string): Promise<Chat> {
+    return await this.join(processJoinLink(link) ?? link);
+  }
+
+  async resolveGroupByLink(link: string): Promise<Chat | null> {
+    const processed = processJoinLink(link);
+    if (!processed) throw new TypeError("Invalid group link");
+    const frame = await this.app.invoke(Opcode.LINK_INFO, { link: processed });
+    return this.optionalChat(payloadItem(frame, "chat"));
+  }
+
+  async reworkInviteLink(chatId: MaxId): Promise<Chat> {
+    const frame = await this.app.invoke(Opcode.CHAT_UPDATE, { revokePrivateLink: true, chatId });
+    const chat = this.optionalChat(payloadItem(frame, "chat"));
+    if (!chat) throw new TsMaxError("Chat not found in response");
+    return chat;
+  }
+
+  async getChats(chatIds: MaxId[]): Promise<Chat[]> {
+    const missing = chatIds.filter((id) => !this.cache.has(id));
+    if (missing.length > 0) {
+      const frame = await this.app.invoke(Opcode.CHAT_INFO, { chatIds: missing });
+      for (const raw of listItem(frame, "chats")) this.cacheChat(Chat.fromPayload(raw));
+    }
+    return chatIds.flatMap((id) => {
+      const chat = this.cache.get(id);
+      return chat ? [chat] : [];
+    });
+  }
+
+  async getChat(chatId: MaxId): Promise<Chat> {
+    const chat = (await this.getChats([chatId]))[0];
+    if (!chat) throw new TsMaxError("Chat not found in response");
+    return chat;
+  }
+
+  async fetchChats(marker = Date.now()): Promise<Chat[]> {
+    const frame = await this.app.invoke(Opcode.CHATS_LIST, { marker });
+    return listItem(frame, "chats").map((raw) => this.cacheChat(Chat.fromPayload(raw)));
+  }
+
+  async leaveGroup(chatId: MaxId): Promise<void> {
+    await this.app.invoke(Opcode.CHAT_LEAVE, { chatId });
+    this.cache.delete(chatId);
+  }
+
+  async leaveChannel(chatId: MaxId): Promise<void> {
+    await this.leaveGroup(chatId);
+  }
+
+  async deleteChat(chatId: MaxId, forMe = true, lastEventTime = Date.now()): Promise<boolean> {
+    await this.app.invoke(Opcode.CHAT_DELETE, { chatId, lastEventTime, forAll: !forMe });
+    this.cache.delete(chatId);
+    return true;
+  }
+
+  async getJoinRequests(chatId: MaxId, count = 100): Promise<Record<string, unknown>[]> {
+    return listItem(
+      await this.app.invoke(Opcode.CHAT_MEMBERS, { chatId, type: "JOIN_REQUEST", count }),
+      "members",
+    ).map((item) => asRecord(item));
+  }
+
+  async confirmJoinRequests(
+    chatId: MaxId,
+    userIds: MaxId[],
+    showHistory = true,
+  ): Promise<Chat | null> {
+    return await this.memberAction(chatId, userIds, "add", showHistory, "JOIN_REQUEST");
+  }
+
+  async confirmJoinRequest(chatId: MaxId, userId: MaxId, showHistory = true): Promise<Chat | null> {
+    return await this.confirmJoinRequests(chatId, [userId], showHistory);
+  }
+
+  async declineJoinRequests(chatId: MaxId, userIds: MaxId[]): Promise<Chat | null> {
+    return await this.memberAction(chatId, userIds, "remove", null, "JOIN_REQUEST");
+  }
+
+  async declineJoinRequest(chatId: MaxId, userId: MaxId): Promise<Chat | null> {
+    return await this.declineJoinRequests(chatId, [userId]);
+  }
+
+  private async join(link: string): Promise<Chat> {
+    const frame = await this.app.invoke(Opcode.CHAT_JOIN, { link });
+    const chat = this.optionalChat(payloadItem(frame, "chat"));
+    if (!chat) throw new TsMaxError("Chat not found in response");
+    return chat;
+  }
+
+  private async memberAction(
+    chatId: MaxId,
+    userIds: MaxId[],
+    operation: "add" | "remove",
+    showHistory: boolean | null,
+    type?: string,
+  ): Promise<Chat | null> {
+    const frame = await this.app.invoke(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId,
+      userIds,
+      operation,
+      showHistory,
+      ...(type ? { type } : {}),
+    });
+    return this.optionalChat(payloadItem(frame, "chat"));
+  }
+
+  private optionalChat(raw: unknown): Chat | null {
+    return raw ? this.cacheChat(Chat.fromPayload(raw)) : null;
+  }
+  private cacheChat(chat: Chat): Chat {
+    const bound = this.app.bindChat(chat);
+    this.cache.set(bound.id, bound);
+    return bound;
+  }
+}
+
+function processJoinLink(link: string): string | null {
+  const index = link.indexOf("join/");
+  return index >= 0 ? link.slice(index) : null;
+}

package/src/api/facade.ts

@@ -0,0 +1,28 @@
+import { AccountApi } from "./account.ts";
+import { AuthApi } from "./auth.ts";
+import { BotsApi } from "./bots.ts";
+import { ChatApi } from "./chats.ts";
+import { MessageApi } from "./messages.ts";
+import type { ApiRuntime } from "./runtime.ts";
+import { UploadApi } from "./uploads.ts";
+import { UserApi } from "./users.ts";
+
+export class ApiFacade {
+  readonly auth: AuthApi;
+  readonly uploads: UploadApi;
+  readonly messages: MessageApi;
+  readonly chats: ChatApi;
+  readonly users: UserApi;
+  readonly account: AccountApi;
+  readonly bots: BotsApi;
+
+  constructor(app: ApiRuntime) {
+    this.auth = new AuthApi(app);
+    this.uploads = new UploadApi(app);
+    this.messages = new MessageApi(app, this.uploads);
+    this.chats = new ChatApi(app);
+    this.users = new UserApi(app);
+    this.account = new AccountApi(app, this.uploads);
+    this.bots = new BotsApi(app);
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,9 @@
+export * from "./account.ts";
+export * from "./auth.ts";
+export * from "./bots.ts";
+export * from "./chats.ts";
+export * from "./facade.ts";
+export * from "./messages.ts";
+export * from "./runtime.ts";
+export * from "./uploads.ts";
+export * from "./users.ts";

package/src/api/messages.ts

@@ -0,0 +1,230 @@
+import type { SendAttachment } from "../files/index.ts";
+import { formatMarkdown } from "../formatting/index.ts";
+import { Opcode } from "../protocol/index.ts";
+import {
+  Message,
+  asRecord,
+  parseReactionInfo,
+  parseReadState,
+  toMaxId,
+  type EditMessageOptions,
+  type ForwardMessageOptions,
+  type HistoryOptions,
+  type MaxId,
+  type MessageActions,
+  type ReactionInfo,
+  type ReadState,
+  type SendMessageOptions,
+} from "../types/index.ts";
+import { listItem, payload, payloadItem, requiredItem } from "./response.ts";
+import type { ApiRuntime } from "./runtime.ts";
+import type { UploadApi, UploadedAttachment } from "./uploads.ts";
+
+export class MessageApi implements MessageActions {
+  private previousCid = Date.now();
+
+  constructor(
+    private readonly app: ApiRuntime,
+    private readonly uploads: UploadApi,
+  ) {}
+
+  async sendMessage(options: SendMessageOptions): Promise<Message | null> {
+    const formatted = formatMarkdown(options.text);
+    const attaches = await this.uploadAttachments(
+      options.attachments as readonly SendAttachment[] | null,
+    );
+    const link = options.replyTo ? { type: "REPLY", messageId: options.replyTo } : undefined;
+    const frame = await this.app.invoke(Opcode.MSG_SEND, {
+      chatId: options.chatId,
+      message: {
+        text: formatted.text,
+        cid: this.nextCid(),
+        elements: formatted.elements,
+        attaches,
+        ...(link ? { link } : {}),
+      },
+      notify: options.notify ?? true,
+    });
+    return this.parseMessage(payload(frame));
+  }
+
+  async forwardMessage(options: ForwardMessageOptions): Promise<Message | null> {
+    const frame = await this.app.invoke(Opcode.MSG_SEND, {
+      chatId: options.chatId,
+      message: {
+        cid: -this.nextCid(),
+        link: {
+          type: "FORWARD",
+          messageId: options.messageId.toString(),
+          chatId: options.sourceChatId ?? options.chatId,
+        },
+        attaches: [],
+      },
+      notify: options.notify ?? true,
+    });
+    return this.parseMessage(payload(frame));
+  }
+
+  async getMessages(chatId: MaxId, messageIds: MaxId[]): Promise<Message[]> {
+    const frame = await this.app.invoke(Opcode.MSG_GET, { chatId, messageIds });
+    return listItem(frame, "messages").map((item) => {
+      const message = this.app.bindMessage(Message.fromPayload(item));
+      message.chatId ??= chatId;
+      return message;
+    });
+  }
+
+  async getMessage(chatId: MaxId, messageId: MaxId): Promise<Message | null> {
+    return (await this.getMessages(chatId, [messageId]))[0] ?? null;
+  }
+
+  async editMessage(options: EditMessageOptions): Promise<Message> {
+    const formatted = formatMarkdown(options.text);
+    const frame = await this.app.invoke(Opcode.MSG_EDIT, {
+      chatId: options.chatId,
+      messageId: options.messageId,
+      text: formatted.text,
+      elements: formatted.elements,
+      attachments: await this.uploadAttachments(
+        options.attachments as readonly SendAttachment[] | null,
+      ),
+    });
+    const message = this.app.bindMessage(Message.fromPayload(requiredItem(frame, "message")));
+    message.chatId ??= options.chatId;
+    return message;
+  }
+
+  async fetchHistory(options: HistoryOptions): Promise<Message[] | null> {
+    const frame = await this.app.invoke(Opcode.CHAT_HISTORY, {
+      chatId: options.chatId,
+      forward: options.forward ?? 0,
+      backward: options.backward ?? 40,
+      backwardTime: options.backwardTime ?? 0,
+      forwardTime: options.forwardTime ?? 0,
+      from: options.from ?? Date.now(),
+      itemType: options.itemType ?? "REGULAR",
+      getChat: options.getChat ?? false,
+      getMessages: options.getMessages ?? true,
+      interactive: options.interactive ?? false,
+    });
+    const result = listItem(frame, "messages").map((item) =>
+      this.app.bindMessage(Message.fromPayload(item)),
+    );
+    return result.length > 0 ? result : null;
+  }
+
+  async deleteMessage(options: {
+    chatId: MaxId;
+    messageIds: MaxId[];
+    forMe: boolean;
+  }): Promise<boolean> {
+    await this.app.invoke(Opcode.MSG_DELETE, options);
+    return true;
+  }
+
+  async pinMessage(options: {
+    chatId: MaxId;
+    messageId: MaxId;
+    notifyPin: boolean;
+  }): Promise<boolean> {
+    await this.app.invoke(Opcode.CHAT_UPDATE, {
+      chatId: options.chatId,
+      notifyPin: options.notifyPin,
+      pinMessageId: options.messageId,
+    });
+    return true;
+  }
+
+  async readMessage(messageId: MaxId, chatId: MaxId): Promise<ReadState> {
+    const frame = await this.app.invoke(Opcode.CHAT_MARK, {
+      type: "READ_MESSAGE",
+      chatId,
+      messageId,
+      mark: Date.now(),
+    });
+    return parseReadState(payload(frame));
+  }
+
+  async addReaction(
+    chatId: MaxId,
+    messageId: MaxId,
+    reaction: string,
+  ): Promise<ReactionInfo | null> {
+    const frame = await this.app.invoke(Opcode.MSG_REACTION, {
+      chatId,
+      messageId: messageId.toString(),
+      reaction: { id: reaction },
+    });
+    return parseReactionInfo(payloadItem(frame, "reactionInfo"));
+  }
+
+  async removeReaction(chatId: MaxId, messageId: MaxId): Promise<ReactionInfo | null> {
+    const frame = await this.app.invoke(Opcode.MSG_CANCEL_REACTION, {
+      chatId,
+      messageId: messageId.toString(),
+    });
+    return parseReactionInfo(payloadItem(frame, "reactionInfo"));
+  }
+
+  async getReactions(chatId: MaxId, messageIds: MaxId[]): Promise<Map<MaxId, ReactionInfo> | null> {
+    const frame = await this.app.invoke(Opcode.MSG_GET_REACTIONS, {
+      chatId,
+      messageIds: messageIds.map(String),
+    });
+    const raw = payloadItem(frame, "messagesReactions");
+    if (!raw) return null;
+    const result = new Map<MaxId, ReactionInfo>();
+    for (const [id, info] of Object.entries(asRecord(raw))) {
+      const parsed = parseReactionInfo(info);
+      if (parsed) result.set(toMaxId(id), parsed);
+    }
+    return result;
+  }
+
+  async getVideoById(
+    chatId: MaxId,
+    messageId: MaxId,
+    videoId: number,
+  ): Promise<Record<string, unknown> | null> {
+    const frame = await this.app.invoke(Opcode.VIDEO_PLAY, {
+      chatId,
+      messageId: messageId.toString(),
+      videoId,
+    });
+    return frame.payload;
+  }
+
+  async getFileById(
+    chatId: MaxId,
+    messageId: MaxId,
+    fileId: number,
+  ): Promise<Record<string, unknown> | null> {
+    const frame = await this.app.invoke(Opcode.FILE_DOWNLOAD, {
+      chatId,
+      messageId: messageId.toString(),
+      fileId,
+    });
+    return frame.payload;
+  }
+
+  private nextCid(): bigint {
+    const next = Math.max(Date.now(), this.previousCid + 1);
+    this.previousCid = next;
+    return BigInt(next);
+  }
+
+  private async uploadAttachments(
+    attachments?: readonly SendAttachment[] | null,
+  ): Promise<UploadedAttachment[]> {
+    const result: UploadedAttachment[] = [];
+    for (const attachment of attachments ?? []) result.push(await this.uploads.upload(attachment));
+    return result;
+  }
+
+  private parseMessage(value: unknown): Message | null {
+    if (!value) return null;
+    const data = asRecord(value);
+    const candidate = data.message ?? value;
+    return this.app.bindMessage(Message.fromPayload(candidate));
+  }
+}

package/src/api/response.ts

@@ -0,0 +1,24 @@
+import type { InboundFrame } from "../protocol/index.ts";
+import { asArray, asRecord } from "../types/index.ts";
+
+export function payload(frame: InboundFrame): Record<string, unknown> {
+  return frame.payload ?? {};
+}
+
+export function payloadItem(frame: InboundFrame, key: string): unknown {
+  return payload(frame)[key];
+}
+
+export function requiredItem(frame: InboundFrame, key: string): unknown {
+  const value = payloadItem(frame, key);
+  if (value === null || value === undefined) throw new TypeError(`Response is missing ${key}`);
+  return value;
+}
+
+export function recordItem(frame: InboundFrame, key?: string): Record<string, unknown> {
+  return asRecord(key ? requiredItem(frame, key) : payload(frame));
+}
+
+export function listItem(frame: InboundFrame, key: string): unknown[] {
+  return asArray(payloadItem(frame, key));
+}

package/src/api/runtime.ts

@@ -0,0 +1,27 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { InboundFrame } from "../protocol/index.ts";
+import type { SessionInfo, SessionStore } from "../session/index.ts";
+import type { Chat, Message, Profile, User } from "../types/index.ts";
+
+export interface ApiRuntime {
+  readonly config: ResolvedConfig;
+  readonly store: SessionStore;
+  session: SessionInfo | null;
+  me: Profile | null;
+  invoke(
+    opcode: number,
+    payload?: Record<string, unknown>,
+    timeout?: number,
+  ): Promise<InboundFrame>;
+  bindMessage(message: Message): Message;
+  bindChat(chat: Chat): Chat;
+  bindUser(user: User): User;
+  createAttachmentWaiter?(
+    field: "fileId" | "videoId",
+    id: number,
+    timeoutSeconds?: number,
+  ): {
+    promise: Promise<void>;
+    cancel(): void;
+  };
+}

package/src/api/uploads.ts

@@ -0,0 +1,91 @@
+import { UploadError } from "../errors.ts";
+import { File, Photo, Video, type SendAttachment } from "../files/index.ts";
+import { Opcode } from "../protocol/index.ts";
+import { asArray, asNumber, asRecord, asString } from "../types/index.ts";
+import { payload } from "./response.ts";
+import type { ApiRuntime } from "./runtime.ts";
+
+export type UploadedAttachment =
+  | { _type: "PHOTO"; photoToken: string }
+  | { _type: "VIDEO"; videoId: number; token: string }
+  | { _type: "FILE"; fileId: number };
+
+export class UploadApi {
+  constructor(private readonly app: ApiRuntime) {}
+
+  async upload(attachment: SendAttachment): Promise<UploadedAttachment> {
+    if (attachment instanceof Photo) return await this.uploadPhoto(attachment);
+    if (attachment instanceof Video) return await this.uploadVideo(attachment);
+    if (attachment instanceof File) return await this.uploadFile(attachment);
+    throw new UploadError("Unsupported attachment");
+  }
+
+  async uploadPhoto(photo: Photo, profile = false): Promise<UploadedAttachment> {
+    const response = payload(await this.app.invoke(Opcode.PHOTO_UPLOAD, { count: 1, profile }));
+    const url = asString(response.url);
+    if (!url) throw new UploadError("No photo upload URL received");
+    const photoId = new URL(url).searchParams.get("photoIds");
+    if (!photoId) throw new UploadError("Photo upload URL has no photoIds");
+    const form = new FormData();
+    const bytes = await photo.read();
+    form.append(
+      "file",
+      new Blob([bytes], { type: photo.format.mimeType }),
+      `image.${photo.format.extension}`,
+    );
+    const upload = await fetch(url, { method: "POST", body: form });
+    if (!upload.ok) throw new UploadError(`Photo upload failed with status ${upload.status}`);
+    const result = asRecord(await upload.json(), "photo upload response");
+    const photos = asRecord(result.photos, "photos");
+    const item = asRecord(photos[photoId], "photo result");
+    const token = asString(item.token);
+    if (!token) throw new UploadError("Photo upload response has no token");
+    return { _type: "PHOTO", photoToken: token };
+  }
+
+  async uploadVideo(video: Video): Promise<UploadedAttachment> {
+    const response = payload(
+      await this.app.invoke(Opcode.VIDEO_UPLOAD, { count: 1, profile: false }),
+    );
+    const info = asRecord(asArray(response.info)[0], "video upload info");
+    const videoId = asNumber(info.videoId);
+    const token = asString(info.token);
+    const waiter = this.app.createAttachmentWaiter?.("videoId", videoId, 60);
+    try {
+      await this.postBinary(asString(info.url), video, true);
+      await waiter?.promise;
+      return { _type: "VIDEO", videoId, token };
+    } finally {
+      waiter?.cancel();
+    }
+  }
+
+  async uploadFile(file: File): Promise<UploadedAttachment> {
+    const response = payload(
+      await this.app.invoke(Opcode.FILE_UPLOAD, { count: 1, profile: false }),
+    );
+    const info = asRecord(asArray(response.info)[0], "file upload info");
+    const fileId = asNumber(info.fileId);
+    const waiter = this.app.createAttachmentWaiter?.("fileId", fileId, 60);
+    try {
+      await this.postBinary(asString(info.url), file, false);
+      await waiter?.promise;
+      return { _type: "FILE", fileId };
+    } finally {
+      waiter?.cancel();
+    }
+  }
+
+  private async postBinary(url: string, file: File | Video, contentRange: boolean): Promise<void> {
+    if (!url) throw new UploadError("No upload URL received");
+    const bytes = await file.read();
+    const headers: Record<string, string> = {
+      "Content-Disposition": `attachment; filename=${encodeURIComponent(file.name)}`,
+      "Content-Length": String(bytes.byteLength),
+    };
+    if (contentRange || bytes.byteLength > 0)
+      headers["Content-Range"] = `0-${bytes.byteLength - 1}/${bytes.byteLength}`;
+    const response = await fetch(url, { method: "POST", headers, body: bytes });
+    if (!response.ok) throw new UploadError(`Upload failed with status ${response.status}`);
+  }
+}