@imessaging/telegram-mtproto 0.8.3 → 0.8.5

package/package.json

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

package/src/incoming.ts

@@ -378,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/telegram-mtproto-transport.ts

@@ -1,4 +1,9 @@
 import type {
+  PhoneLookupTransport,
+  PhoneMatch,
+  DraftTransport,
+  MessageDraft,
+  OutgoingObserverTransport,
   ButtonPress,
   ButtonPressTransport,
   IncomingAttachment,
@@ -20,7 +25,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";
@@ -35,6 +40,7 @@ import { StringSession } from "telegram/sessions";
 import {
   downloadFromMessage,
   IncomingDispatcher,
+  OutgoingDispatcher,
   toIncomingMessage,
   type DownloadingClient,
   type MtprotoMessageLike,
@@ -88,12 +94,28 @@ function isChannel(chat: Api.TypeChat): chat is Api.Channel {
   return chat.className === "Channel";
 }
 
+const OWN_MEMORY_MS = 10 * 60 * 1000;
+
+/** Номер не занят Telegram или не принят в этой форме — «не найдено», а не отказ. */
+const PHONE_NOT_FOUND_ERRORS = new Set(["PHONE_NOT_OCCUPIED", "PHONE_NUMBER_INVALID"]);
+
+/** Номер чата входного пира в том же маркированном виде, что 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,
+    PhoneLookupTransport,
     ReactionTransport,
     ReadReceiptTransport,
     TypingTransport
@@ -107,6 +129,18 @@ export class TelegramMtprotoTransport
   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;
 
@@ -192,6 +226,193 @@ export class TelegramMtprotoTransport
     };
   }
 
+  /**
+   * Учётка по номеру телефона: сначала contacts.ResolvePhone (номер, открытый настройками приватности),
+   * затем contacts.ImportContacts (номер виден только контакту). Контакт, заведённый ради поиска, сразу
+   * удаляется — адресная книга не растёт; бывший контактом до поиска остаётся на месте.
+   */
+  async findByPhone(phone: string): Promise<PhoneMatch | null> {
+    this.assertConnected();
+    const digits = phone.replace(/[\s()-]/g, "").replace(/^\+/, "");
+    if (!/^\d{7,15}$/.test(digits))
+      throw new Error(`Phone must be E.164, e.g. +79991234567: ${phone}`);
+
+    // Одни серверы ждут номер без «+», другие с ним — так вёл поиск и прежний клиент italent.
+    for (const variant of [digits, `+${digits}`]) {
+      try {
+        const resolved = await this.client.invoke(
+          new Api.contacts.ResolvePhone({ phone: variant }),
+        );
+        const peer = resolved.peer;
+        const user = isPeerUser(peer)
+          ? resolved.users.find((u): u is Api.User => isUser(u) && u.id.equals(peer.userId))
+          : undefined;
+        if (user) return this.rememberPhoneMatch(user);
+      } catch (error: unknown) {
+        if (!PHONE_NOT_FOUND_ERRORS.has((error as TelegramRpcError).errorMessage ?? ""))
+          throw error;
+      }
+    }
+
+    const known = new Set(
+      (await this.client.invoke(new Api.contacts.GetContactIDs({ hash: bigInt(0) }))).map(String),
+    );
+    const imported = await this.client.invoke(
+      new Api.contacts.ImportContacts({
+        contacts: [
+          new Api.InputPhoneContact({
+            clientId: bigInt(Date.now()),
+            phone: `+${digits}`,
+            firstName: `+${digits}`,
+            lastName: "",
+          }),
+        ],
+      }),
+    );
+    const user = imported.users.find((u): u is Api.User => isUser(u));
+    if (!user) return null;
+    try {
+      return await this.rememberPhoneMatch(user);
+    } finally {
+      if (!known.has(user.id.toString()) && user.accessHash) {
+        await this.client.invoke(
+          new Api.contacts.DeleteContacts({
+            id: [new Api.InputUser({ userId: user.id, accessHash: user.accessHash })],
+          }),
+        );
+      }
+    }
+  }
+
+  private async rememberPhoneMatch(user: Api.User): Promise<PhoneMatch> {
+    const userId = user.id.toString();
+    if (user.accessHash) {
+      await this.peerStore.set(
+        this.options.accountId,
+        { type: "user", id: userId },
+        {
+          type: "user",
+          id: userId,
+          accessHash: user.accessHash.toString(),
+          ...(user.username ? { username: user.username } : {}),
+          resolvedAt: new Date().toISOString(),
+        },
+        this.options.peerTtlSeconds,
+      );
+    }
+    return {
+      userId,
+      ...(user.username ? { username: user.username } : {}),
+      ...(user.firstName ? { firstName: user.firstName } : {}),
+    };
+  }
+
+  /**
+   * Черновик в поле ввода чата — ответ готовит машина, отправляет человек. Разметка — тем же рендером, что у
+   * 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();
@@ -392,7 +613,7 @@ export class TelegramMtprotoTransport
 
   async send(message: OutboundMessage): Promise<SendResult> {
     this.assertConnected();
-    return this.sendWithRetry(message, false);
+    return this.trackOwn(this.sendWithRetry(message, false));
   }
 
   /**
@@ -408,7 +629,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> {
@@ -548,13 +769,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 {
@@ -705,6 +928,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();