@bruch/max-client 0.1.0

package/src/client.ts

@@ -0,0 +1,506 @@
+import type { AccountApi, AuthApi, BotsApi, ChatApi, ContactInfo, UserApi } from "./api/index.ts";
+import { App } from "./app.ts";
+import {
+  QrAuthFlow,
+  SmsAuthFlow,
+  type AuthFlow,
+  type PasswordProvider,
+  type QrHandler,
+  type SmsCodeProvider,
+} from "./auth/index.ts";
+import { resolveConfig, type ExtraConfig, type ResolvedConfig } from "./config.ts";
+import { ConnectionManager, TcpReader, WsReader } from "./connection/index.ts";
+import {
+  Router,
+  type DisconnectHandler,
+  type ErrorHandler,
+  type Filter,
+  type Handler,
+  type StartHandler,
+} from "./dispatch/index.ts";
+import { configureLogging } from "./logging.ts";
+import { TcpProtocol, WsProtocol, type InboundFrame } from "./protocol/index.ts";
+import type { SessionInfo } from "./session/index.ts";
+import { TcpTransport, WebSocketTransport } from "./transport/index.ts";
+import type {
+  Chat,
+  ChatActions,
+  EditMessageOptions,
+  ForwardMessageOptions,
+  HistoryOptions,
+  MaxId,
+  Message,
+  MessageActions,
+  MessageDeleteEvent,
+  MessageReadEvent,
+  PresenceEvent,
+  ReactionInfo,
+  ReactionUpdateEvent,
+  ReadState,
+  SendMessageOptions,
+  TypingEvent,
+  User,
+  UserActions,
+} from "./types/index.ts";
+
+export interface ClientOptions {
+  phone: string;
+  sessionName?: string;
+  workDir?: string;
+  extraConfig?: ExtraConfig;
+  authFlow?: AuthFlow;
+  smsCodeProvider?: SmsCodeProvider;
+  passwordProvider?: PasswordProvider;
+}
+
+export interface WebClientOptions {
+  sessionName?: string;
+  workDir?: string;
+  extraConfig?: ExtraConfig;
+  authFlow?: AuthFlow;
+  qrHandler?: QrHandler;
+  passwordProvider?: PasswordProvider;
+}
+
+export abstract class BaseClient implements MessageActions, ChatActions, UserActions {
+  readonly router = new Router<BaseClient>();
+  protected app: App<BaseClient>;
+  readonly config: ResolvedConfig;
+  private stopping = false;
+
+  protected constructor(config: ResolvedConfig, _authFlow: AuthFlow, app: App<BaseClient>) {
+    this.config = config;
+    configureLogging(config.logLevel);
+    this.app = app;
+    this.app.bindClient(this);
+  }
+
+  get me() {
+    return this.app.me;
+  }
+  get chats(): Chat[] {
+    return this.app.chats;
+  }
+  get contacts(): Array<User | null> {
+    return this.app.contacts;
+  }
+  get messages(): Map<bigint, Message[]> {
+    return this.app.messages;
+  }
+  get session(): SessionInfo | null {
+    return this.app.session;
+  }
+  get api() {
+    return this.app.api;
+  }
+  get account(): AccountApi {
+    return this.api.account;
+  }
+  get auth(): AuthApi {
+    return this.api.auth;
+  }
+  get bots(): BotsApi {
+    return this.api.bots;
+  }
+  get chatApi(): ChatApi {
+    return this.api.chats;
+  }
+  get users(): UserApi {
+    return this.api.users;
+  }
+
+  async start(): Promise<void> {
+    this.stopping = false;
+    for (;;) {
+      try {
+        await this.app.start();
+        await this.app.dispatcher.emitStart();
+        await this.app.connection.waitClosed();
+        await this.app.close();
+        return;
+      } catch (error) {
+        await this.app.close();
+        if (this.stopping) return;
+        const failure = error instanceof Error ? error : new Error(String(error));
+        await this.app.dispatcher.emitDisconnect(
+          failure,
+          this.config.reconnect,
+          this.config.reconnectDelay,
+        );
+        if (!this.config.reconnect) throw failure;
+        await Bun.sleep(this.config.reconnectDelay * 1000);
+        this.app = this.rebuildApp();
+        this.app.bindClient(this);
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.stopping = true;
+    await this.app.close();
+  }
+  async close(): Promise<void> {
+    await this.stop();
+  }
+  async relogin(start = true): Promise<void> {
+    if (!this.app.session) throw new Error("Cannot relogin before session is loaded");
+    await this.app.store.deleteSession(this.app.session.token);
+    await this.app.close();
+    this.config.token = null;
+    this.app = this.rebuildApp();
+    this.app.bindClient(this);
+    if (start) await this.start();
+  }
+
+  includeRouter(router: Router<BaseClient>): () => void {
+    return this.router.includeRouter(router);
+  }
+  onStart(handler: StartHandler<BaseClient>): () => void {
+    return this.router.onStart(handler);
+  }
+  onError(handler: ErrorHandler<BaseClient>): () => void {
+    return this.router.onError(handler);
+  }
+  onDisconnect(handler: DisconnectHandler): () => void {
+    return this.router.onDisconnect(handler);
+  }
+  onMessage(handler: Handler<Message, BaseClient>, ...filters: Filter<Message>[]): () => void {
+    return this.router.onMessage(handler, ...filters);
+  }
+  onMessageEdit(handler: Handler<Message, BaseClient>, ...filters: Filter<Message>[]): () => void {
+    return this.router.onMessageEdit(handler, ...filters);
+  }
+  onMessageDelete(
+    handler: Handler<MessageDeleteEvent, BaseClient>,
+    ...filters: Filter<MessageDeleteEvent>[]
+  ): () => void {
+    return this.router.onMessageDelete(handler, ...filters);
+  }
+  onMessageRead(
+    handler: Handler<MessageReadEvent, BaseClient>,
+    ...filters: Filter<MessageReadEvent>[]
+  ): () => void {
+    return this.router.onMessageRead(handler, ...filters);
+  }
+  onTyping(
+    handler: Handler<TypingEvent, BaseClient>,
+    ...filters: Filter<TypingEvent>[]
+  ): () => void {
+    return this.router.onTyping(handler, ...filters);
+  }
+  onPresence(
+    handler: Handler<PresenceEvent, BaseClient>,
+    ...filters: Filter<PresenceEvent>[]
+  ): () => void {
+    return this.router.onPresence(handler, ...filters);
+  }
+  onReactionUpdate(
+    handler: Handler<ReactionUpdateEvent, BaseClient>,
+    ...filters: Filter<ReactionUpdateEvent>[]
+  ): () => void {
+    return this.router.onReactionUpdate(handler, ...filters);
+  }
+  onChatUpdate(handler: Handler<Chat, BaseClient>, ...filters: Filter<Chat>[]): () => void {
+    return this.router.onChatUpdate(handler, ...filters);
+  }
+  onRaw(
+    handler: Handler<InboundFrame, BaseClient>,
+    ...filters: Filter<InboundFrame>[]
+  ): () => void {
+    return this.router.onRaw(handler, ...filters);
+  }
+
+  async sendMessage(options: SendMessageOptions): Promise<Message | null> {
+    return await this.api.messages.sendMessage(options);
+  }
+  async forwardMessage(options: ForwardMessageOptions): Promise<Message | null> {
+    return await this.api.messages.forwardMessage(options);
+  }
+  async getMessages(chatId: MaxId, messageIds: MaxId[]): Promise<Message[]> {
+    return await this.api.messages.getMessages(chatId, messageIds);
+  }
+  async getMessage(chatId: MaxId, messageId: MaxId): Promise<Message | null> {
+    return await this.api.messages.getMessage(chatId, messageId);
+  }
+  async editMessage(options: EditMessageOptions): Promise<Message> {
+    return await this.api.messages.editMessage(options);
+  }
+  async fetchHistory(options: HistoryOptions): Promise<Message[] | null> {
+    return await this.api.messages.fetchHistory(options);
+  }
+  async deleteMessage(options: {
+    chatId: MaxId;
+    messageIds: MaxId[];
+    forMe: boolean;
+  }): Promise<boolean> {
+    return await this.api.messages.deleteMessage(options);
+  }
+  async pinMessage(options: {
+    chatId: MaxId;
+    messageId: MaxId;
+    notifyPin: boolean;
+  }): Promise<boolean> {
+    return await this.api.messages.pinMessage(options);
+  }
+  async readMessage(messageId: MaxId, chatId: MaxId): Promise<ReadState> {
+    return await this.api.messages.readMessage(messageId, chatId);
+  }
+  async addReaction(
+    chatId: MaxId,
+    messageId: MaxId,
+    reaction: string,
+  ): Promise<ReactionInfo | null> {
+    return await this.api.messages.addReaction(chatId, messageId, reaction);
+  }
+  async removeReaction(chatId: MaxId, messageId: MaxId): Promise<ReactionInfo | null> {
+    return await this.api.messages.removeReaction(chatId, messageId);
+  }
+  async getReactions(chatId: MaxId, messageIds: MaxId[]): Promise<Map<MaxId, ReactionInfo> | null> {
+    return await this.api.messages.getReactions(chatId, messageIds);
+  }
+  async getVideoById(chatId: MaxId, messageId: MaxId, videoId: number) {
+    return await this.api.messages.getVideoById(chatId, messageId, videoId);
+  }
+  async getFileById(chatId: MaxId, messageId: MaxId, fileId: number) {
+    return await this.api.messages.getFileById(chatId, messageId, fileId);
+  }
+
+  async createGroup(name: string, participantIds: MaxId[] = [], notify = true) {
+    return await this.api.chats.createGroup(name, participantIds, notify);
+  }
+  async inviteUsersToGroup(
+    chatId: MaxId,
+    userIds: MaxId[],
+    showHistory = true,
+  ): Promise<Chat | null> {
+    return await this.api.chats.inviteUsersToGroup(chatId, userIds, showHistory);
+  }
+  async inviteUsersToChannel(
+    chatId: MaxId,
+    userIds: MaxId[],
+    showHistory = true,
+  ): Promise<Chat | null> {
+    return await this.api.chats.inviteUsersToChannel(chatId, userIds, showHistory);
+  }
+  async removeUsersFromGroup(chatId: MaxId, userIds: MaxId[]): Promise<Chat | null> {
+    return await this.api.chats.removeUsersFromGroup(chatId, userIds);
+  }
+  async getChats(chatIds: MaxId[]): Promise<Chat[]> {
+    return await this.api.chats.getChats(chatIds);
+  }
+  async getChat(chatId: MaxId): Promise<Chat> {
+    return await this.api.chats.getChat(chatId);
+  }
+  async fetchChats(marker?: number): Promise<Chat[]> {
+    return await this.api.chats.fetchChats(marker);
+  }
+  async joinGroup(link: string): Promise<Chat> {
+    return await this.api.chats.joinGroup(link);
+  }
+  async joinChannel(link: string): Promise<Chat> {
+    return await this.api.chats.joinChannel(link);
+  }
+  async leaveGroup(chatId: MaxId): Promise<void> {
+    await this.api.chats.leaveGroup(chatId);
+  }
+  async leaveChannel(chatId: MaxId): Promise<void> {
+    await this.api.chats.leaveChannel(chatId);
+  }
+  async deleteChat(chatId: MaxId, forMe = true): Promise<boolean> {
+    return await this.api.chats.deleteChat(chatId, forMe);
+  }
+  async changeGroupSettings(
+    chatId: MaxId,
+    settings: Parameters<ChatApi["changeGroupSettings"]>[1],
+  ): Promise<void> {
+    await this.api.chats.changeGroupSettings(chatId, settings);
+  }
+  async changeGroupProfile(
+    chatId: MaxId,
+    name: string | null,
+    description: string | null = null,
+  ): Promise<void> {
+    await this.api.chats.changeGroupProfile(chatId, name, description);
+  }
+  async resolveGroupByLink(link: string): Promise<Chat | null> {
+    return await this.api.chats.resolveGroupByLink(link);
+  }
+  async reworkInviteLink(chatId: MaxId): Promise<Chat> {
+    return await this.api.chats.reworkInviteLink(chatId);
+  }
+  async getJoinRequests(chatId: MaxId, count = 100) {
+    return await this.api.chats.getJoinRequests(chatId, count);
+  }
+  async confirmJoinRequests(
+    chatId: MaxId,
+    userIds: MaxId[],
+    showHistory = true,
+  ): Promise<Chat | null> {
+    return await this.api.chats.confirmJoinRequests(chatId, userIds, showHistory);
+  }
+  async confirmJoinRequest(chatId: MaxId, userId: MaxId, showHistory = true): Promise<Chat | null> {
+    return await this.api.chats.confirmJoinRequest(chatId, userId, showHistory);
+  }
+  async declineJoinRequests(chatId: MaxId, userIds: MaxId[]): Promise<Chat | null> {
+    return await this.api.chats.declineJoinRequests(chatId, userIds);
+  }
+  async declineJoinRequest(chatId: MaxId, userId: MaxId): Promise<Chat | null> {
+    return await this.api.chats.declineJoinRequest(chatId, userId);
+  }
+
+  getCachedUser(userId: MaxId): User | null {
+    return this.api.users.getCachedUser(userId);
+  }
+  async getUsers(userIds: MaxId[]): Promise<User[]> {
+    return await this.api.users.getUsers(userIds);
+  }
+  async getUser(userId: MaxId): Promise<User | null> {
+    return await this.api.users.getUser(userId);
+  }
+  async fetchUsers(userIds: MaxId[]): Promise<User[]> {
+    return await this.api.users.fetchUsers(userIds);
+  }
+  async searchByPhone(phone: string): Promise<User> {
+    return await this.api.users.searchByPhone(phone);
+  }
+  async addContact(contactId: MaxId): Promise<User> {
+    return await this.api.users.addContact(contactId);
+  }
+  async removeContact(contactId: MaxId): Promise<boolean> {
+    return await this.api.users.removeContact(contactId);
+  }
+  async importContacts(contacts: ContactInfo[]): Promise<User[]> {
+    return await this.api.users.importContacts(contacts);
+  }
+  getChatId(firstUserId: MaxId, secondUserId: MaxId): MaxId {
+    return this.api.users.getChatId(firstUserId, secondUserId);
+  }
+
+  async setTwoFactor(options: Parameters<AuthApi["setTwoFactor"]>[0]): Promise<boolean> {
+    return await this.auth.setTwoFactor(options);
+  }
+  async removeTwoFactor(password: string): Promise<boolean> {
+    return await this.auth.removeTwoFactor(password);
+  }
+  async changePassword(oldPassword: string, newPassword: string): Promise<boolean> {
+    return await this.auth.changePassword(oldPassword, newPassword);
+  }
+  async authorizeQrLogin(qrLink: string): Promise<boolean> {
+    return await this.auth.authorizeQrLogin(qrLink);
+  }
+  async checkTwoFactor(): Promise<boolean> {
+    return await this.auth.checkTwoFactor();
+  }
+  async changeProfile(options: Parameters<AccountApi["changeProfile"]>[0]): Promise<boolean> {
+    return await this.account.changeProfile(options);
+  }
+  async requestProfilePhotoUploadUrl(): Promise<string> {
+    return await this.account.requestProfilePhotoUploadUrl();
+  }
+  async createFolder(
+    title: string,
+    chatInclude: MaxId[],
+    filters: unknown[] = [],
+  ): Promise<Record<string, unknown>> {
+    return await this.account.createFolder(title, chatInclude, filters);
+  }
+  async getFolders(folderSync = 0): Promise<Record<string, unknown>> {
+    return await this.account.getFolders(folderSync);
+  }
+  async updateFolder(
+    folderId: string,
+    title: string,
+    chatInclude: MaxId[] = [],
+    filters: unknown[] = [],
+    options: unknown[] = [],
+  ): Promise<Record<string, unknown>> {
+    return await this.account.updateFolder(folderId, title, chatInclude, filters, options);
+  }
+  async deleteFolder(folderId: string): Promise<Record<string, unknown>> {
+    return await this.account.deleteFolder(folderId);
+  }
+  async closeAllSessions(): Promise<boolean> {
+    return await this.account.closeAllSessions();
+  }
+  async logout(): Promise<boolean> {
+    return await this.account.logout();
+  }
+  async getSessions(): Promise<Record<string, unknown>[]> {
+    return await this.users.getSessions();
+  }
+  async getBotInitData(botId: MaxId, chatId?: MaxId | null, startParam?: string | null) {
+    return await this.bots.getBotInitData(botId, chatId, startParam);
+  }
+
+  protected abstract rebuildApp(): App<BaseClient>;
+}
+
+export class Client extends BaseClient {
+  private readonly authFlow: AuthFlow;
+
+  constructor(options: ClientOptions) {
+    const config = resolveConfig({
+      phone: options.phone,
+      ...(options.workDir !== undefined ? { workDir: options.workDir } : {}),
+      ...(options.sessionName !== undefined ? { sessionName: options.sessionName } : {}),
+      ...(options.extraConfig !== undefined ? { extra: options.extraConfig } : {}),
+    });
+    const authFlow =
+      options.authFlow ?? new SmsAuthFlow(options.smsCodeProvider, options.passwordProvider);
+    const transport = new TcpTransport(config.host, config.port, config.useTls, config.proxy);
+    const connection = new ConnectionManager(
+      new TcpReader(transport),
+      transport,
+      new TcpProtocol(),
+    );
+    const placeholder = new Router<BaseClient>();
+    const app = new App(connection, config, authFlow, placeholder);
+    super(config, authFlow, app);
+    this.authFlow = authFlow;
+    app.dispatcher.rootRouter.children.push(this.router);
+  }
+
+  protected rebuildApp(): App<BaseClient> {
+    const transport = new TcpTransport(
+      this.config.host,
+      this.config.port,
+      this.config.useTls,
+      this.config.proxy,
+    );
+    const connection = new ConnectionManager(
+      new TcpReader(transport),
+      transport,
+      new TcpProtocol(),
+    );
+    return new App(connection, this.config, this.authFlow, this.router);
+  }
+}
+
+export class WebClient extends BaseClient {
+  private readonly authFlow: AuthFlow;
+
+  constructor(options: WebClientOptions = {}) {
+    const config = resolveConfig({
+      phone: null,
+      ...(options.workDir !== undefined ? { workDir: options.workDir } : {}),
+      ...(options.sessionName !== undefined ? { sessionName: options.sessionName } : {}),
+      web: true,
+      ...(options.extraConfig !== undefined ? { extra: options.extraConfig } : {}),
+    });
+    const authFlow =
+      options.authFlow ?? new QrAuthFlow(options.qrHandler, options.passwordProvider);
+    const transport = new WebSocketTransport(config.url, config.proxy);
+    const connection = new ConnectionManager(new WsReader(transport), transport, new WsProtocol());
+    const placeholder = new Router<BaseClient>();
+    const app = new App(connection, config, authFlow, placeholder);
+    super(config, authFlow, app);
+    this.authFlow = authFlow;
+    app.dispatcher.rootRouter.children.push(this.router);
+  }
+
+  protected rebuildApp(): App<BaseClient> {
+    const transport = new WebSocketTransport(this.config.url, this.config.proxy);
+    const connection = new ConnectionManager(new WsReader(transport), transport, new WsProtocol());
+    return new App(connection, this.config, this.authFlow, this.router);
+  }
+}

package/src/config.ts

@@ -0,0 +1,161 @@
+import { defaultSyncState, type SessionStore, type SyncOverrides } from "./session/index.ts";
+
+export const DeviceType = {
+  WEB: "WEB",
+  ANDROID: "ANDROID",
+  IOS: "IOS",
+  DESKTOP: "DESKTOP",
+} as const;
+export type DeviceType = (typeof DeviceType)[keyof typeof DeviceType];
+
+export interface UserAgent {
+  deviceType: DeviceType;
+  appVersion: string;
+  osVersion: string;
+  timezone: string;
+  screen: string;
+  locale: string;
+  deviceName: string;
+  deviceLocale: string;
+  pushDeviceType?: string;
+  arch?: string;
+  buildNumber?: number;
+  release?: number;
+  headerUserAgent?: string;
+}
+
+export interface RegistrationConfig {
+  firstName: string;
+  lastName?: string | null;
+}
+
+export interface ExtraConfig {
+  token?: string | null;
+  registrationConfig?: RegistrationConfig | null;
+  host?: string;
+  port?: number;
+  url?: string;
+  useTls?: boolean;
+  proxy?: string | null;
+  reconnect?: boolean;
+  reconnectDelay?: number;
+  deviceId?: string;
+  deviceType?: DeviceType;
+  userAgent?: UserAgent;
+  mtInstanceId?: string;
+  requestTimeout?: number;
+  logLevel?: "DEBUG" | "INFO" | "WARN" | "ERROR" | "SILENT";
+  telemetry?: boolean;
+  store?: SessionStore;
+  sync?: SyncOverrides;
+}
+
+export interface ResolvedConfig {
+  phone: string | null;
+  workDir: string;
+  sessionName: string;
+  token: string | null;
+  registrationConfig: RegistrationConfig | null;
+  host: string;
+  port: number;
+  url: string;
+  useTls: boolean;
+  proxy: string | null;
+  reconnect: boolean;
+  reconnectDelay: number;
+  requestTimeout: number;
+  logLevel: "DEBUG" | "INFO" | "WARN" | "ERROR" | "SILENT";
+  telemetry: boolean;
+  store?: SessionStore;
+  sync: SyncOverrides;
+  device: {
+    deviceId: string;
+    mtInstanceId: string;
+    clientSessionId: number;
+    userAgent: UserAgent;
+  };
+}
+
+const androidAgents: readonly Omit<UserAgent, "appVersion" | "buildNumber">[] = [
+  {
+    deviceType: DeviceType.ANDROID,
+    osVersion: "Android 14",
+    timezone: "Europe/Moscow",
+    screen: "411dpi 411dpi 1080x2400",
+    pushDeviceType: "GCM",
+    arch: "arm64-v8a",
+    locale: "ru",
+    deviceName: "Pixel 8",
+    deviceLocale: "ru",
+  },
+  {
+    deviceType: DeviceType.ANDROID,
+    osVersion: "Android 14",
+    timezone: "Europe/Moscow",
+    screen: "425dpi 425dpi 1080x2340",
+    pushDeviceType: "GCM",
+    arch: "arm64-v8a",
+    locale: "ru",
+    deviceName: "Samsung SM-S911B",
+    deviceLocale: "ru",
+  },
+];
+
+export function resolveConfig(options: {
+  phone?: string | null;
+  workDir?: string;
+  sessionName?: string;
+  web?: boolean;
+  extra?: ExtraConfig;
+}): ResolvedConfig {
+  const extra = options.extra ?? {};
+  const userAgent = extra.userAgent ?? (options.web ? createWebAgent() : createMobileAgent());
+  return {
+    phone: options.phone ?? null,
+    workDir: options.workDir ?? ".",
+    sessionName: options.sessionName ?? "session.db",
+    token: extra.token ?? null,
+    registrationConfig: extra.registrationConfig ?? null,
+    host: extra.host ?? "api.oneme.ru",
+    port: extra.port ?? 443,
+    url: extra.url ?? "wss://ws-api.oneme.ru/websocket",
+    useTls: extra.useTls ?? true,
+    proxy: extra.proxy ?? null,
+    reconnect: extra.reconnect ?? true,
+    reconnectDelay: extra.reconnectDelay ?? 1,
+    requestTimeout: extra.requestTimeout ?? 30,
+    logLevel: extra.logLevel ?? "INFO",
+    telemetry: extra.telemetry ?? true,
+    ...(extra.store ? { store: extra.store } : {}),
+    sync: extra.sync ?? defaultSyncState(),
+    device: {
+      deviceId: extra.deviceId ?? crypto.randomUUID(),
+      mtInstanceId: extra.mtInstanceId ?? crypto.randomUUID(),
+      clientSessionId: Math.floor(Math.random() * 70) + 1,
+      userAgent,
+    },
+  };
+}
+
+function createMobileAgent(): UserAgent {
+  const base = androidAgents[Math.floor(Math.random() * androidAgents.length)] as Omit<
+    UserAgent,
+    "appVersion" | "buildNumber"
+  >;
+  return { ...base, appVersion: "26.14.1", buildNumber: 6686 };
+}
+
+function createWebAgent(): UserAgent {
+  return {
+    deviceType: DeviceType.WEB,
+    appVersion: "26.5.5",
+    osVersion: "Linux",
+    timezone: "Europe/Moscow",
+    screen: "1080x1920 1.0x",
+    locale: "ru",
+    deviceName: "Chrome",
+    deviceLocale: "ru",
+    headerUserAgent:
+      "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
+  };
+}