@overpod/mcp-telegram 1.8.1 → 1.9.0

package/dist/index.js

@@ -183,7 +183,7 @@ server.tool("telegram-search-chats", "Search for Telegram chats/users/channels b
     try {
         const results = await telegram.searchChats(query, limit);
         const text = results
-            .map((c) => `${c.type === "group" ? "G" : c.type === "channel" ? "C" : "P"} ${c.name}${c.username ? ` (@${c.username})` : ""} (${c.id})`)
+            .map((c) => `${c.type === "group" ? "G" : c.type === "channel" ? "C" : "P"} ${c.name}${c.username ? ` (@${c.username})` : ""} (${c.id})${c.membersCount ? ` [${c.membersCount} members]` : ""}${c.description ? ` — ${c.description.split("\n")[0].slice(0, 100)}` : ""}`)
             .join("\n");
         return { content: [{ type: "text", text: text || "No results" }] };
     }
@@ -191,6 +191,26 @@ server.tool("telegram-search-chats", "Search for Telegram chats/users/channels b
         return { content: [{ type: "text", text: `Error: ${e.message}` }] };
     }
 });
+server.tool("telegram-search-global", "Search messages globally across all public Telegram chats and channels", {
+    query: z.string().describe("Search text"),
+    limit: z.number().default(20).describe("Max results"),
+    minDate: z.number().optional().describe("Unix timestamp: only messages after this date"),
+    maxDate: z.number().optional().describe("Unix timestamp: only messages before this date"),
+}, async ({ query, limit, minDate, maxDate }) => {
+    const err = await requireConnection();
+    if (err)
+        return { content: [{ type: "text", text: err }] };
+    try {
+        const messages = await telegram.searchGlobal(query, limit, minDate, maxDate);
+        const text = messages
+            .map((m) => `[${m.date}] [${m.chat.type === "channel" ? "C" : m.chat.type === "group" ? "G" : "P"} ${m.chat.name}${m.chat.username ? ` @${m.chat.username}` : ""}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}`)
+            .join("\n\n");
+        return { content: [{ type: "text", text: text || "No messages found" }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
 server.tool("telegram-search-messages", "Search messages in a Telegram chat by text", {
     chatId: z.string().describe("Chat ID or username"),
     query: z.string().describe("Search text"),

package/dist/telegram-client.d.ts

@@ -116,6 +116,25 @@ export declare class TelegramService {
         name: string;
         type: string;
         username?: string;
+        membersCount?: number;
+        description?: string;
+    }>>;
+    searchGlobal(query: string, limit?: number, minDate?: number, maxDate?: number): Promise<Array<{
+        id: number;
+        text: string;
+        sender: string;
+        date: string;
+        chat: {
+            id: string;
+            name: string;
+            type: string;
+            username?: string;
+        };
+        media?: {
+            type: string;
+            fileName?: string;
+            size?: number;
+        };
     }>>;
     searchMessages(chatId: string, query: string, limit?: number, minDate?: number, maxDate?: number): Promise<Array<{
         id: number;

package/dist/telegram-client.js

@@ -642,7 +642,12 @@ export class TelegramService {
         }
         for (const chat of result.chats) {
             if (chat instanceof Api.Chat) {
-                chats.push({ id: chat.id.toString(), name: chat.title, type: "group" });
+                chats.push({
+                    id: chat.id.toString(),
+                    name: chat.title,
+                    type: "group",
+                    membersCount: chat.participantsCount ?? undefined,
+                });
             }
             else if (chat instanceof Api.Channel) {
                 chats.push({
@@ -650,11 +655,104 @@ export class TelegramService {
                     name: chat.title,
                     type: chat.megagroup ? "group" : "channel",
                     username: chat.username ?? undefined,
+                    membersCount: chat.participantsCount ?? undefined,
                 });
             }
         }
+        // Enrich channels/groups with description and accurate members count
+        for (const chat of chats) {
+            if (chat.type === "private")
+                continue;
+            try {
+                const entity = await this.client.getEntity(chat.id);
+                if (entity instanceof Api.Channel) {
+                    const full = await this.client.invoke(new Api.channels.GetFullChannel({ channel: entity }));
+                    if (full.fullChat instanceof Api.ChannelFull) {
+                        chat.description = full.fullChat.about || undefined;
+                        chat.membersCount = full.fullChat.participantsCount ?? chat.membersCount;
+                    }
+                }
+                else if (entity instanceof Api.Chat) {
+                    const full = await this.client.invoke(new Api.messages.GetFullChat({ chatId: entity.id }));
+                    if (full.fullChat instanceof Api.ChatFull) {
+                        chat.description = full.fullChat.about || undefined;
+                    }
+                }
+            }
+            catch {
+                // Skip enrichment on error (private channels, etc.)
+            }
+        }
         return chats;
     }
+    async searchGlobal(query, limit = 20, minDate, maxDate) {
+        if (!this.client || !this.connected)
+            throw new Error("Not connected");
+        const result = await this.client.invoke(new Api.messages.SearchGlobal({
+            q: query,
+            filter: new Api.InputMessagesFilterEmpty(),
+            minDate: minDate || 0,
+            maxDate: maxDate || 0,
+            offsetRate: 0,
+            offsetPeer: new Api.InputPeerEmpty(),
+            offsetId: 0,
+            limit,
+        }));
+        const chatsMap = new Map();
+        if ("chats" in result) {
+            for (const chat of result.chats) {
+                if (chat instanceof Api.Channel) {
+                    chatsMap.set(chat.id.toString(), {
+                        id: chat.id.toString(),
+                        name: chat.title,
+                        type: chat.megagroup ? "group" : "channel",
+                        username: chat.username ?? undefined,
+                    });
+                }
+                else if (chat instanceof Api.Chat) {
+                    chatsMap.set(chat.id.toString(), {
+                        id: chat.id.toString(),
+                        name: chat.title,
+                        type: "group",
+                    });
+                }
+            }
+        }
+        if ("users" in result) {
+            for (const user of result.users) {
+                if (user instanceof Api.User) {
+                    const parts = [user.firstName, user.lastName].filter(Boolean);
+                    chatsMap.set(user.id.toString(), {
+                        id: user.id.toString(),
+                        name: parts.join(" ") || "Unknown",
+                        type: "private",
+                        username: user.username ?? undefined,
+                    });
+                }
+            }
+        }
+        const rawMessages = "messages" in result ? result.messages : [];
+        const messages = rawMessages.filter((m) => m instanceof Api.Message);
+        const results = await Promise.all(messages.map(async (m) => {
+            const peerId = m.peerId;
+            let chatId = "";
+            if (peerId instanceof Api.PeerChannel)
+                chatId = peerId.channelId.toString();
+            else if (peerId instanceof Api.PeerChat)
+                chatId = peerId.chatId.toString();
+            else if (peerId instanceof Api.PeerUser)
+                chatId = peerId.userId.toString();
+            return {
+                id: m.id,
+                text: m.message ?? "",
+                sender: await this.resolveSenderName(m.senderId),
+                date: new Date((m.date ?? 0) * 1000).toISOString(),
+                chat: chatsMap.get(chatId) || { id: chatId, name: "Unknown", type: "unknown" },
+                media: this.extractMediaInfo(m.media),
+            };
+        }));
+        return results;
+    }
     async searchMessages(chatId, query, limit = 20, minDate, maxDate) {
         if (!this.client || !this.connected)
             throw new Error("Not connected");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@overpod/mcp-telegram",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "MCP server for Telegram userbot — messages, media, reactions, polls & more. Built on GramJS/MTProto.",
   "type": "module",
   "main": "dist/index.js",