@imessaging/telegram-mtproto 0.8.2 → 0.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imessaging/telegram-mtproto",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Telegram MTProto user-account transport for imessaging",
   "keywords": [
     "messaging",
@@ -31,7 +31,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@imessaging/core": "^0.8.2",
+    "@imessaging/core": "^0.8.4",
     "big-integer": "^1.6.52"
   },
   "peerDependencies": {

package/src/entities.ts

@@ -22,6 +22,10 @@ export function toTelegramEntities(ft: FormattedText): Api.TypeMessageEntity[] {
         return new Api.MessageEntityPre({ ...base, language: e.language ?? "" });
       case "link":
         return new Api.MessageEntityTextUrl({ ...base, url: e.url ?? "" });
+      case "spoiler":
+        return new Api.MessageEntitySpoiler(base);
+      case "quote":
+        return new Api.MessageEntityBlockquote(base);
     }
   });
 }

package/src/incoming.ts

@@ -1,4 +1,10 @@
-import type { IncomingAttachment, IncomingLink, IncomingMessage } from "@imessaging/core";
+import type {
+  IncomingAttachment,
+  IncomingLink,
+  IncomingMessage,
+  TextEntity,
+  TextEntityType,
+} from "@imessaging/core";
 
 /** Пир MTProto в той части, по которой определяется чат. Приходит из `Api.TypePeer`. */
 export type MtprotoPeerLike = {
@@ -93,6 +99,7 @@ export type MtprotoEntityLike = {
   offset?: number;
   length?: number;
   url?: string;
+  language?: string;
 };
 
 /** Кнопка под сообщением. Адрес несёт только `KeyboardButtonUrl`, у остальных его нет. */
@@ -233,6 +240,35 @@ export function collectLinks(message: MtprotoMessageLike): IncomingLink[] {
   return links;
 }
 
+const FORMATTING: Record<string, TextEntityType> = {
+  MessageEntityBold: "bold",
+  MessageEntityItalic: "italic",
+  MessageEntityUnderline: "underline",
+  MessageEntityStrike: "strike",
+  MessageEntitySpoiler: "spoiler",
+  MessageEntityCode: "code",
+  MessageEntityPre: "pre",
+  MessageEntityTextUrl: "link",
+  MessageEntityBlockquote: "quote",
+};
+
+export function formattingEntities(message: MtprotoMessageLike): TextEntity[] {
+  const result: TextEntity[] = [];
+  for (const entity of message.entities ?? []) {
+    // Упоминания, хэштеги, голые адреса — не форматирование: пары в общей модели у них нет.
+    const type = FORMATTING[entity.className ?? ""];
+    if (!type || entity.offset === undefined || entity.length === undefined) continue;
+    result.push({
+      type,
+      offset: entity.offset,
+      length: entity.length,
+      ...(type === "link" && entity.url ? { url: entity.url } : {}),
+      ...(type === "pre" && entity.language ? { language: entity.language } : {}),
+    });
+  }
+  return result;
+}
+
 /**
  * Сообщение живой учётной записи → общий вид.
  *
@@ -297,6 +333,7 @@ export function toIncomingMessage(
     sentAt: message.date ? new Date(message.date * 1000) : undefined,
     // Непоправленное сообщение приходит с `editDate: null` — это не правка в 1970 году.
     editedAt: message.editDate ? new Date(message.editDate * 1000) : undefined,
+    entities: formattingEntities(message),
     attachments: collectAttachments(message, chatId),
     links: collectLinks(message),
     mentionsMe: typeof message.mentioned === "boolean" ? message.mentioned : undefined,
@@ -341,6 +378,38 @@ export class IncomingDispatcher {
   }
 }
 
+/**
+ * Раздача СВОИХ исходящих — зеркало IncomingDispatcher: отдаёт только `out: true`, чужое пропускает.
+ * Своё ли это отправление транспорта, решает вызывающий: он знает, что сам отправлял.
+ */
+export class OutgoingDispatcher {
+  private readonly handlers = new Set<(message: IncomingMessage) => void | Promise<void>>();
+
+  add(handler: (message: IncomingMessage) => void | Promise<void>): () => void {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+
+  get size(): number {
+    return this.handlers.size;
+  }
+
+  async dispatch(
+    message: MtprotoMessageLike,
+    transportId: string,
+    accountId: string,
+    sentByTransport: boolean,
+  ): Promise<boolean> {
+    if (message.out !== true) return false;
+    if (this.handlers.size === 0) return false;
+    const outgoing = { ...toIncomingMessage(message, transportId, accountId), sentByTransport };
+    for (const handler of this.handlers) await handler(outgoing);
+    return true;
+  }
+}
+
 /** Клиент MTProto в той части, которой достаточно для скачивания. Объявлен ради двойника в тесте. */
 export type DownloadingClient = {
   getMessages(peer: string, params: { ids: number[] }): Promise<{ media?: unknown }[]>;

package/src/index.ts

@@ -7,6 +7,7 @@ export {
   collectAttachments,
   collectLinks,
   downloadFromMessage,
+  formattingEntities,
   IncomingDispatcher,
   peerToChat,
   unmarkPeerId,

package/src/telegram-mtproto-transport.ts

@@ -1,4 +1,7 @@
 import type {
+  DraftTransport,
+  MessageDraft,
+  OutgoingObserverTransport,
   ButtonPress,
   ButtonPressTransport,
   IncomingAttachment,
@@ -7,6 +10,7 @@ import type {
   ReadReceiptTransport,
   EditableMessage,
   EditableMessageTransport,
+  EditedMessageTransport,
   EditResult,
   MessageReaction,
   MessageRecipient,
@@ -19,7 +23,7 @@ import type {
   TransportStatus,
   TypingTransport,
 } from "@imessaging/core";
-import { isTelegramRecipient, MemoryPeerStore, formattedOf } from "@imessaging/core";
+import { formatText, formattedOf, isTelegramRecipient, MemoryPeerStore } from "@imessaging/core";
 import { toTelegramEntities } from "./entities";
 import { peerToChat, unmarkPeerId } from "./incoming";
 import bigInt from "big-integer";
@@ -27,12 +31,14 @@ import { Api, TelegramClient } from "telegram";
 import { CustomFile } from "telegram/client/uploads";
 import { CallbackQuery } from "telegram/events/CallbackQuery";
 import { NewMessage } from "telegram/events/NewMessage";
+import { EditedMessage } from "telegram/events/EditedMessage";
 import type { TelegramClientParams } from "telegram/client/telegramBaseClient";
 import { StringSession } from "telegram/sessions";
 
 import {
   downloadFromMessage,
   IncomingDispatcher,
+  OutgoingDispatcher,
   toIncomingMessage,
   type DownloadingClient,
   type MtprotoMessageLike,
@@ -86,11 +92,24 @@ function isChannel(chat: Api.TypeChat): chat is Api.Channel {
   return chat.className === "Channel";
 }
 
+const OWN_MEMORY_MS = 10 * 60 * 1000;
+
+/** Номер чата входного пира в том же маркированном виде, что chatId во входящем (peerToChat). */
+function inputPeerChatId(peer: Api.TypeInputPeer): string {
+  if (peer instanceof Api.InputPeerChannel) return peerToChat({ channelId: peer.channelId }).chatId;
+  if (peer instanceof Api.InputPeerChat) return peerToChat({ chatId: peer.chatId }).chatId;
+  if (peer instanceof Api.InputPeerUser) return peerToChat({ userId: peer.userId }).chatId;
+  throw new Error(`Unsupported input peer: ${peer.className}`);
+}
+
 export class TelegramMtprotoTransport
   implements
+    DraftTransport,
     EditableMessageTransport,
+    EditedMessageTransport,
     ButtonPressTransport,
     IncomingMessageTransport,
+    OutgoingObserverTransport,
     ReactionTransport,
     ReadReceiptTransport,
     TypingTransport
@@ -102,6 +121,20 @@ export class TelegramMtprotoTransport
   private lastActivityAt?: Date;
   private readonly incoming = new IncomingDispatcher();
   private incomingListener: ((event: unknown) => void) | null = null;
+  private readonly edits = new IncomingDispatcher();
+  private editListener: ((event: unknown) => void) | null = null;
+  private readonly outgoing = new OutgoingDispatcher();
+  private outgoingListener: ((event: unknown) => void) | null = null;
+  private readonly outgoingEdits = new OutgoingDispatcher();
+  private outgoingEditListener: ((event: unknown) => void) | null = null;
+  /**
+   * Что отправил и поправил сам транспорт: «чат:сообщение» → когда. Своё приходит тем же обновлением
+   * out=true, что и отправленное человеком с телефона, и без этой памяти их не различить.
+   */
+  private readonly ownSent = new Map<string, number>();
+  private readonly ownEdited = new Map<string, number>();
+  /** Идущие send/edit: обновление о своём сообщении может прийти раньше, чем вызов вернёт его номер. */
+  private readonly ownPending = new Set<Promise<unknown>>();
   /** Отметка жизни подписки: срабатывает на любом обновлении, включая служебные. */
   private activityListener: ((event: unknown) => void) | null = null;
 
@@ -187,6 +220,140 @@ export class TelegramMtprotoTransport
     };
   }
 
+  /**
+   * Черновик в поле ввода чата — ответ готовит машина, отправляет человек. Разметка — тем же рендером, что у
+   * send (`format`); без него текст уходит как есть. Пустой текст очищает черновик.
+   */
+  async saveDraft(draft: MessageDraft): Promise<void> {
+    this.assertConnected();
+    if (!isTelegramRecipient(draft.recipient)) {
+      throw new Error(`Telegram MTProto cannot save a draft for ${draft.recipient.type}`);
+    }
+    const replyTo =
+      draft.replyToMessageId === undefined ? undefined : Number(draft.replyToMessageId);
+    if (replyTo !== undefined && (!Number.isSafeInteger(replyTo) || replyTo <= 0)) {
+      throw new Error(`Telegram message id must be a positive integer: ${draft.replyToMessageId}`);
+    }
+    const ft = draft.format ? formatText(draft.text, draft.format) : undefined;
+    const save = async (peer: Api.TypeInputPeer) =>
+      this.client.invoke(
+        new Api.messages.SaveDraft({
+          peer,
+          message: ft ? ft.text : draft.text,
+          ...(ft && ft.entities.length > 0 ? { entities: toTelegramEntities(ft) } : {}),
+          ...(replyTo ? { replyTo: new Api.InputReplyToMessage({ replyToMsgId: replyTo }) } : {}),
+        }),
+      );
+    try {
+      await save(await this.getInputPeer(draft.recipient));
+    } catch (error: unknown) {
+      // Как у send: устаревший пир из хранилища — забыть и разрешить заново, один раз.
+      if (!this.isInvalidPeerError(error)) throw error;
+      await this.peerStore.delete(this.options.accountId, draft.recipient);
+      await save(await this.getInputPeer(draft.recipient));
+    }
+    this.lastActivityAt = new Date();
+  }
+
+  /** Свои новые исходящие — отправленное человеком с другого устройства; отправленное через send помечено sentByTransport. */
+  onOutgoing(handler: (message: IncomingMessage) => void | Promise<void>): () => void {
+    const remove = this.outgoing.add(handler);
+    if (this.outgoingListener === null) {
+      this.outgoingListener = (event: unknown): void => {
+        const message = (event as { message?: MtprotoMessageLike }).message;
+        if (!message) return;
+        this.lastActivityAt = new Date();
+        void this.dispatchOwn(this.outgoing, this.ownSent, message);
+      };
+      this.client.addEventHandler(this.outgoingListener, new NewMessage({ outgoing: true }));
+    }
+    return () => {
+      remove();
+      if (this.outgoing.size > 0 || this.outgoingListener === null) return;
+      this.client.removeEventHandler(this.outgoingListener, new NewMessage({ outgoing: true }));
+      this.outgoingListener = null;
+    };
+  }
+
+  /** Правки своих сообщений; поправленное через edit помечено sentByTransport. */
+  onOutgoingEdit(handler: (message: IncomingMessage) => void | Promise<void>): () => void {
+    const remove = this.outgoingEdits.add(handler);
+    if (this.outgoingEditListener === null) {
+      this.outgoingEditListener = (event: unknown): void => {
+        const message = (event as { message?: MtprotoMessageLike }).message;
+        if (!message) return;
+        this.lastActivityAt = new Date();
+        void this.dispatchOwn(this.outgoingEdits, this.ownEdited, message);
+      };
+      this.client.addEventHandler(this.outgoingEditListener, new EditedMessage({ outgoing: true }));
+    }
+    return () => {
+      remove();
+      if (this.outgoingEdits.size > 0 || this.outgoingEditListener === null) return;
+      this.client.removeEventHandler(
+        this.outgoingEditListener,
+        new EditedMessage({ outgoing: true }),
+      );
+      this.outgoingEditListener = null;
+    };
+  }
+
+  private async dispatchOwn(
+    dispatcher: OutgoingDispatcher,
+    own: Map<string, number>,
+    message: MtprotoMessageLike,
+  ): Promise<void> {
+    if (message.out !== true || !message.peerId) return;
+    // Своё ли это, известно только после того, как идущие send/edit вернули номера.
+    await Promise.allSettled(this.ownPending);
+    const key = `${peerToChat(message.peerId).chatId}:${message.id}`;
+    await dispatcher.dispatch(message, this.id, this.options.accountId, own.has(key));
+  }
+
+  private trackOwn<T>(work: Promise<T>): Promise<T> {
+    this.ownPending.add(work);
+    void work.then(
+      () => this.ownPending.delete(work),
+      () => this.ownPending.delete(work),
+    );
+    return work;
+  }
+
+  /** Номер своего сообщения; память на 10 минут — обновление приходит за секунды, дольше держать незачем. */
+  private rememberOwn(own: Map<string, number>, peer: Api.TypeInputPeer, messageId: number): void {
+    const now = Date.now();
+    for (const [key, at] of own) if (now - at > OWN_MEMORY_MS) own.delete(key);
+    own.set(`${inputPeerChatId(peer)}:${messageId}`, now);
+  }
+
+  onEdit(handler: (message: IncomingMessage) => void | Promise<void>): () => void {
+    const remove = this.edits.add(handler);
+    this.startEditListeningIfNeeded();
+    return () => {
+      remove();
+      this.stopEditListeningIfIdle();
+    };
+  }
+
+  private startEditListeningIfNeeded(): void {
+    if (this.editListener !== null || this.edits.size === 0) return;
+    const listener = (event: unknown): void => {
+      const message = (event as { message?: MtprotoMessageLike }).message;
+      if (!message) return;
+      this.lastActivityAt = new Date();
+      void this.rememberSender(message);
+      void this.edits.dispatch(message, this.id, this.options.accountId);
+    };
+    this.editListener = listener;
+    this.client.addEventHandler(listener, new EditedMessage({}));
+  }
+
+  private stopEditListeningIfIdle(): void {
+    if (this.edits.size > 0 || this.editListener === null) return;
+    this.client.removeEventHandler(this.editListener, new EditedMessage({}));
+    this.editListener = null;
+  }
+
   private startListeningIfNeeded(): void {
     if (this.incomingListener !== null || this.incoming.size === 0) return;
     const listener = (event: unknown): void => {
@@ -359,7 +526,7 @@ export class TelegramMtprotoTransport
 
   async send(message: OutboundMessage): Promise<SendResult> {
     this.assertConnected();
-    return this.sendWithRetry(message, false);
+    return this.trackOwn(this.sendWithRetry(message, false));
   }
 
   /**
@@ -375,7 +542,7 @@ export class TelegramMtprotoTransport
    */
   async edit(message: EditableMessage): Promise<EditResult> {
     this.assertConnected();
-    return this.editWithRetry(message, false);
+    return this.trackOwn(this.editWithRetry(message, false));
   }
 
   async getStatus(): Promise<TransportStatus> {
@@ -515,13 +682,15 @@ export class TelegramMtprotoTransport
         formattingEntities,
         replyTo: message.replyToMessageId ?? message.threadId,
       });
+      this.rememberOwn(this.ownSent, peer, sent.id);
       for (const document of message.documents ?? []) {
         const data = Buffer.from(document.data);
-        await this.client.sendFile(peer, {
+        const file = await this.client.sendFile(peer, {
           file: new CustomFile(document.filename, data.length, "", data),
           caption: document.caption,
           replyTo: message.threadId,
         });
+        this.rememberOwn(this.ownSent, peer, file.id);
       }
       this.lastActivityAt = new Date();
       return {
@@ -672,6 +841,8 @@ export class TelegramMtprotoTransport
     let peer: Api.TypeInputPeer | null = null;
     try {
       peer = await this.getInputPeer(message.recipient);
+      // До вызова: обновление о правке может прийти раньше ответа на неё.
+      this.rememberOwn(this.ownEdited, peer, messageId);
       const ft = formattedOf(message);
       const text = ft ? ft.text : message.text;
       const parseMode = ft ? undefined : message.parseMode?.toLowerCase();