@imessaging/telegram-mtproto 0.1.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@imessaging/telegram-mtproto",
+  "version": "0.1.0",
+  "description": "Telegram MTProto user-account transport for imessaging",
+  "keywords": [
+    "messaging",
+    "mtproto",
+    "telegram",
+    "transport",
+    "userbot"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iconicompany/imessaging.git",
+    "directory": "packages/telegram-mtproto"
+  },
+  "files": [
+    "src"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "type-check": "bunx tsgo --noEmit -p tsconfig.json",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@imessaging/core": "0.1.0",
+    "big-integer": "^1.6.52"
+  },
+  "peerDependencies": {
+    "telegram": ">=1.224.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export {
+  TelegramMtprotoTransport,
+  type TelegramMtprotoTransportOptions,
+} from "./telegram-mtproto-transport";

package/src/telegram-mtproto-transport.ts

@@ -0,0 +1,235 @@
+import type {
+  MessageRecipient,
+  MessageTransport,
+  OutboundMessage,
+  ResolvedPeer,
+  SendResult,
+  TelegramPeerStore,
+  TransportStatus,
+} from "@imessaging/core";
+import { MemoryPeerStore } from "@imessaging/core";
+import bigInt from "big-integer";
+import { Api, TelegramClient } from "telegram";
+import { CustomFile } from "telegram/client/uploads";
+import type { TelegramClientParams } from "telegram/client/telegramBaseClient";
+import { StringSession } from "telegram/sessions";
+
+export type TelegramMtprotoTransportOptions = {
+  accountId: string;
+  apiId: number;
+  apiHash: string;
+  session: string;
+  connectionRetries?: number;
+  clientOptions?: TelegramClientParams;
+  peerStore?: TelegramPeerStore;
+  peerTtlSeconds?: number;
+};
+
+type TelegramRpcError = {
+  code?: number;
+  errorMessage?: string;
+};
+
+const INVALID_PEER_ERRORS = new Set([
+  "PEER_ID_INVALID",
+  "ACCESS_TOKEN_EXPIRED",
+  "PEER_ID_NOT_SUPPORTED",
+]);
+
+function isPeerUser(peer: Api.TypePeer): peer is Api.PeerUser {
+  return peer.className === "PeerUser";
+}
+
+function isPeerChannel(peer: Api.TypePeer): peer is Api.PeerChannel {
+  return peer.className === "PeerChannel";
+}
+
+function isUser(user: Api.TypeUser): user is Api.User {
+  return user.className === "User";
+}
+
+function isChannel(chat: Api.TypeChat): chat is Api.Channel {
+  return chat.className === "Channel";
+}
+
+export class TelegramMtprotoTransport implements MessageTransport {
+  readonly id: string;
+  private readonly client: TelegramClient;
+  private readonly peerStore: TelegramPeerStore;
+  private connected = false;
+  private lastActivityAt?: Date;
+
+  constructor(private readonly options: TelegramMtprotoTransportOptions) {
+    if (!options.accountId.trim()) throw new Error("accountId must not be empty");
+
+    this.id = `telegram-mtproto:${options.accountId}`;
+    this.peerStore = options.peerStore ?? new MemoryPeerStore();
+    if (!Number.isInteger(options.apiId) || options.apiId <= 0) {
+      throw new Error("apiId must be a positive integer");
+    }
+    if (!options.apiHash.trim()) throw new Error("apiHash must not be empty");
+    if (!options.session.trim()) throw new Error("session must not be empty");
+    this.client = new TelegramClient(
+      new StringSession(options.session),
+      options.apiId,
+      options.apiHash,
+      {
+        ...options.clientOptions,
+        connectionRetries:
+          options.connectionRetries ?? options.clientOptions?.connectionRetries ?? 5,
+      },
+    );
+  }
+
+  async connect(): Promise<void> {
+    await this.client.connect();
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    await this.client.disconnect();
+    this.connected = false;
+  }
+
+  async send(message: OutboundMessage): Promise<SendResult> {
+    this.assertConnected();
+    return this.sendWithRetry(message, false);
+  }
+
+  async getStatus(): Promise<TransportStatus> {
+    return {
+      connected: this.connected && Boolean(this.client.connected),
+      transportId: this.id,
+      accountId: this.options.accountId,
+      lastActivityAt: this.lastActivityAt,
+    };
+  }
+
+  private async sendWithRetry(message: OutboundMessage, retried: boolean): Promise<SendResult> {
+    try {
+      const peer = await this.getInputPeer(message.recipient);
+      const sent = await this.client.sendMessage(peer, {
+        message: message.text,
+        parseMode: message.parseMode?.toLowerCase(),
+        replyTo: message.replyToMessageId ?? message.threadId,
+      });
+      for (const document of message.documents ?? []) {
+        const data = Buffer.from(document.data);
+        await this.client.sendFile(peer, {
+          file: new CustomFile(document.filename, data.length, "", data),
+          caption: document.caption,
+          replyTo: message.threadId,
+        });
+      }
+      this.lastActivityAt = new Date();
+      return {
+        transportId: this.id,
+        messageId: String(sent.id),
+        recipientId: this.getPeerId(peer),
+      };
+    } catch (error: unknown) {
+      if (retried || !this.isInvalidPeerError(error)) throw error;
+      await this.peerStore.delete(this.options.accountId, message.recipient);
+      return this.sendWithRetry(message, true);
+    }
+  }
+
+  private async getInputPeer(recipient: MessageRecipient): Promise<Api.TypeInputPeer> {
+    const cached = await this.peerStore.get(this.options.accountId, recipient);
+    if (cached) return this.toInputPeer(cached);
+
+    const resolved = await this.resolvePeer(recipient);
+    await this.peerStore.set(
+      this.options.accountId,
+      recipient,
+      resolved,
+      this.options.peerTtlSeconds,
+    );
+    return this.toInputPeer(resolved);
+  }
+
+  private async resolvePeer(recipient: MessageRecipient): Promise<ResolvedPeer> {
+    if (recipient.type !== "username" && !recipient.username) {
+      throw new Error(
+        `Cannot resolve uncached Telegram ${recipient.type} ${recipient.id} without a username`,
+      );
+    }
+    const username = recipient.username;
+    if (!username) {
+      throw new Error(`Cannot resolve Telegram ${recipient.type} without a username`);
+    }
+    const cleanUsername = username.replace(/^@/, "");
+    const result = await this.client.invoke(
+      new Api.contacts.ResolveUsername({ username: cleanUsername }),
+    );
+
+    if (isPeerUser(result.peer)) {
+      const peer = result.peer;
+      const user = result.users.find(
+        (candidate): candidate is Api.User => isUser(candidate) && candidate.id.equals(peer.userId),
+      );
+      if (!user?.accessHash) throw new Error(`No accessHash returned for @${cleanUsername}`);
+      return {
+        type: "user",
+        id: user.id.toString(),
+        accessHash: user.accessHash.toString(),
+        username: cleanUsername,
+        resolvedAt: new Date().toISOString(),
+      };
+    }
+
+    if (isPeerChannel(result.peer)) {
+      const peer = result.peer;
+      const channel = result.chats.find(
+        (candidate): candidate is Api.Channel =>
+          isChannel(candidate) && candidate.id.equals(peer.channelId),
+      );
+      if (!channel?.accessHash) throw new Error(`No accessHash returned for @${cleanUsername}`);
+      return {
+        type: "channel",
+        id: channel.id.toString(),
+        accessHash: channel.accessHash.toString(),
+        username: cleanUsername,
+        resolvedAt: new Date().toISOString(),
+      };
+    }
+
+    throw new Error(`@${cleanUsername} cannot be resolved as a user or channel`);
+  }
+
+  private toInputPeer(peer: ResolvedPeer): Api.TypeInputPeer {
+    if (peer.type === "group") {
+      return new Api.InputPeerChat({ chatId: bigInt(peer.id) });
+    }
+    if (!peer.accessHash) throw new Error(`Cached ${peer.type} peer has no accessHash`);
+    if (peer.type === "user") {
+      return new Api.InputPeerUser({
+        userId: bigInt(peer.id),
+        accessHash: bigInt(peer.accessHash),
+      });
+    }
+    return new Api.InputPeerChannel({
+      channelId: bigInt(peer.id),
+      accessHash: bigInt(peer.accessHash),
+    });
+  }
+
+  private getPeerId(peer: Api.TypeInputPeer): string {
+    if (peer instanceof Api.InputPeerUser) return peer.userId.toString();
+    if (peer instanceof Api.InputPeerChat) return peer.chatId.toString();
+    if (peer instanceof Api.InputPeerChannel) return peer.channelId.toString();
+    throw new Error(`Unsupported input peer: ${peer.className}`);
+  }
+
+  private assertConnected(): void {
+    if (!this.connected || !this.client.connected) {
+      throw new Error(`${this.id} is not connected`);
+    }
+  }
+
+  private isInvalidPeerError(error: unknown): boolean {
+    if (typeof error !== "object" || error === null) return false;
+    const telegramError = error as TelegramRpcError;
+    return telegramError.code === 400 && INVALID_PEER_ERRORS.has(telegramError.errorMessage ?? "");
+  }
+}