@overpod/mcp-telegram 1.25.0 → 1.26.1

package/dist/telegram-client.js

@@ -10,6 +10,8 @@ import { CustomFile } from "telegram/client/uploads.js";
 import { StringSession } from "telegram/sessions/index.js";
 import { Api } from "telegram/tl/index.js";
 import { RateLimiter } from "./rate-limiter.js";
+import { describeAdminLogAction, describeAdminLogDetails, describeKeyboardButton, mergeBannedRights, reactionToEmoji, summarizeAllStories, summarizeBoostsList, summarizeBoostsStatus, summarizeBroadcastStats, summarizeBusinessChatLinks, summarizeChannelDifference, summarizeGroupCall, summarizeGroupCallParticipants, summarizeMegagroupStats, summarizeMyBoosts, summarizePeerStories, summarizeQuickReplies, summarizeQuickReplyMessages, summarizeStarsStatus, summarizeStoriesById, summarizeStoryViewsList, summarizeUpdatesDifference, } from "./telegram-helpers.js";
+export { describeAdminLogAction, describeAdminLogDetails, describeKeyboardButton, mergeBannedRights, peerToCompact, reactionToEmoji, summarizeAllStories, summarizeBoost, summarizeBoostsList, summarizeBoostsStatus, summarizeBroadcastStats, summarizeBusinessChatLink, summarizeBusinessChatLinks, summarizeChannelDifference, summarizeGroupCall, summarizeGroupCallInfo, summarizeGroupCallParticipant, summarizeGroupCallParticipants, summarizeMegagroupStats, summarizeMyBoost, summarizeMyBoosts, summarizePeerStories, summarizePrepaidGiveaway, summarizeQuickReplies, summarizeQuickReply, summarizeQuickReplyMessage, summarizeQuickReplyMessages, summarizeStarsAmount, summarizeStarsStatus, summarizeStarsSubscription, summarizeStarsTransaction, summarizeStarsTransactionPeer, summarizeStoriesById, summarizeStoryItem, summarizeStoryView, summarizeStoryViewsList, summarizeUpdatesDifference, } from "./telegram-helpers.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LEGACY_SESSION_FILE = join(__dirname, "..", ".telegram-session");
 const DEFAULT_SESSION_DIR = join(homedir(), ".mcp-telegram");
@@ -44,137 +46,6 @@ function ensureSessionDir(filePath) {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
 }
-export function describeAdminLogAction(action) {
-    const prefix = "ChannelAdminLogEventAction";
-    const raw = action.className.startsWith(prefix) ? action.className.slice(prefix.length) : action.className;
-    return raw
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-        .replace(/([a-z])([A-Z])/g, "$1_$2")
-        .toLowerCase();
-}
-export function describeAdminLogDetails(action, describeUser) {
-    if (action instanceof Api.ChannelAdminLogEventActionChangeTitle) {
-        return `"${action.prevValue}" → "${action.newValue}"`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionChangeAbout) {
-        return `description changed`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionChangeUsername) {
-        return `@${action.prevValue || "-"} → @${action.newValue || "-"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionUpdatePinned) {
-        return `message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionEditMessage) {
-        return `message #${action.newMessage instanceof Api.Message ? action.newMessage.id : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionDeleteMessage) {
-        return `message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionParticipantInvite) {
-        const p = action.participant;
-        return `invited user ${"userId" in p ? describeUser(p.userId) : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionParticipantToggleBan) {
-        const p = action.newParticipant;
-        if (p instanceof Api.ChannelParticipantBanned) {
-            const uid = p.peer instanceof Api.PeerUser ? p.peer.userId : undefined;
-            return `banned user ${uid ? describeUser(uid) : "?"}`;
-        }
-        return `unbanned user ${"userId" in p ? describeUser(p.userId) : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionParticipantToggleAdmin) {
-        const p = action.newParticipant;
-        return `admin rights changed for ${"userId" in p ? describeUser(p.userId) : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionToggleSlowMode) {
-        return `${action.prevValue}s → ${action.newValue}s`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionToggleInvites) {
-        return `invites ${action.newValue ? "enabled" : "disabled"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionToggleSignatures) {
-        return `signatures ${action.newValue ? "enabled" : "disabled"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionTogglePreHistoryHidden) {
-        return `pre-history hidden: ${action.newValue}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionChangeHistoryTTL) {
-        return `${action.prevValue}s → ${action.newValue}s`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionChangeStickerSet) {
-        return `sticker set changed`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionChangeLinkedChat) {
-        return `${action.prevValue.toString()} → ${action.newValue.toString()}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionStopPoll) {
-        return `poll in message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionSendMessage) {
-        return `message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionCreateTopic) {
-        return `topic "${action.topic instanceof Api.ForumTopic ? action.topic.title : "?"}"`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionDeleteTopic) {
-        return `topic "${action.topic instanceof Api.ForumTopic ? action.topic.title : "?"}"`;
-    }
-    if (action instanceof Api.ChannelAdminLogEventActionEditTopic) {
-        return `topic "${action.newTopic instanceof Api.ForumTopic ? action.newTopic.title : "?"}"`;
-    }
-    return "";
-}
-export function reactionToEmoji(reaction) {
-    if (reaction instanceof Api.ReactionEmoji)
-        return reaction.emoticon;
-    if (reaction instanceof Api.ReactionCustomEmoji)
-        return `custom:${reaction.documentId.toString()}`;
-    if (reaction instanceof Api.ReactionPaid)
-        return "⭐";
-    return null;
-}
-const BANNED_RIGHT_FLAGS = [
-    "sendMessages",
-    "sendMedia",
-    "sendStickers",
-    "sendGifs",
-    "sendPolls",
-    "sendInline",
-    "embedLinks",
-    "changeInfo",
-    "inviteUsers",
-    "pinMessages",
-];
-// Newer granular flags not exposed in ChatPermissions input but must be preserved from currentRights
-const EXTRA_BANNED_RIGHT_FLAGS = [
-    "sendGames",
-    "manageTopics",
-    "sendPhotos",
-    "sendVideos",
-    "sendRoundvideos",
-    "sendAudios",
-    "sendVoices",
-    "sendDocs",
-    "sendPlain",
-];
-export function mergeBannedRights(current, permissions) {
-    const result = {};
-    for (const flag of BANNED_RIGHT_FLAGS) {
-        const userValue = permissions[flag];
-        if (userValue !== undefined) {
-            result[flag] = !userValue;
-        }
-        else {
-            result[flag] = Boolean(current?.[flag]);
-        }
-    }
-    // Preserve newer granular flags from existing rights so they are not silently cleared
-    for (const flag of EXTRA_BANNED_RIGHT_FLAGS) {
-        result[flag] = Boolean(current?.[flag]);
-    }
-    return result;
-}
 export class TelegramService {
     client = null;
     apiId;
@@ -184,6 +55,7 @@ export class TelegramService {
     sessionPath;
     rateLimiter = new RateLimiter();
     lastTypingAt = new Map();
+    entityCache = new Map();
     lastError = "";
     get sessionDir() {
         return dirname(this.sessionPath);
@@ -300,6 +172,7 @@ export class TelegramService {
         this.connected = false;
         this.sessionString = "";
         this.client = null;
+        this.entityCache.clear();
         if (existsSync(this.sessionPath)) {
             await unlink(this.sessionPath);
         }
@@ -317,6 +190,7 @@ export class TelegramService {
             await this.client.destroy();
             this.connected = false;
             this.client = null;
+            this.entityCache.clear();
         }
     }
     /**
@@ -916,13 +790,17 @@ export class TelegramService {
      * Resolve a chat by ID, username, or display name.
      * Falls back to searching user's dialogs if getEntity() fails.
      */
-    // biome-ignore lint: GramJS has no proper entity union type
     async resolveChat(chatId) {
         if (!this.client)
             throw new Error(NOT_CONNECTED_ERROR);
+        const cached = this.entityCache.get(chatId);
+        if (cached)
+            return cached;
         // First try direct resolve (numeric ID, username, phone)
         try {
-            return await this.client.getEntity(chatId);
+            const entity = await this.client.getEntity(chatId);
+            this.entityCache.set(chatId, entity);
+            return entity;
         }
         catch {
             // Fall through to dialog search
@@ -932,12 +810,16 @@ export class TelegramService {
         const query = chatId.toLowerCase();
         // Exact match first
         const exact = dialogs.find((d) => d.title?.toLowerCase() === query);
-        if (exact?.entity)
+        if (exact?.entity) {
+            this.entityCache.set(chatId, exact.entity);
             return exact.entity;
+        }
         // Partial match
         const partial = dialogs.filter((d) => d.title?.toLowerCase().includes(query));
-        if (partial.length === 1 && partial[0].entity)
+        if (partial.length === 1 && partial[0].entity) {
+            this.entityCache.set(chatId, partial[0].entity);
             return partial[0].entity;
+        }
         if (partial.length > 1) {
             const matches = partial.map((d) => `  ${d.title} (${d.entity?.id?.toString() ?? "?"})`).join("\n");
             throw new Error(`Multiple chats match "${chatId}". Use the numeric ID instead:\n${matches}`);
@@ -948,8 +830,10 @@ export class TelegramService {
      * Resolve chatId to a peer string that GramJS methods accept.
      * Handles display names by searching dialogs.
      */
-    // biome-ignore lint: GramJS has no proper entity union type
     async resolvePeer(chatId) {
+        // Normalize '@me' — GramJS only intercepts the plain 'me' string as InputPeerSelf
+        if (chatId === "@me")
+            return "me";
         // Numeric IDs and @usernames work directly
         if (/^-?\d+$/.test(chatId) || chatId.startsWith("@"))
             return chatId;
@@ -2151,6 +2035,375 @@ export class TelegramService {
             await this.client?.invoke(new Api.channels.ToggleSlowMode({ channel: entity, seconds }));
         }, `setSlowMode ${chatId}`);
     }
+    async toggleChannelSignatures(chatId, enabled) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Channel signatures are only available for broadcast channels (not groups or supergroups)");
+            }
+            if (entity.megagroup) {
+                throw new Error("Channel signatures are only available for broadcast channels, not supergroups");
+            }
+            await this.client?.invoke(new Api.channels.ToggleSignatures({ channel: entity, signaturesEnabled: enabled }));
+        }, `toggleChannelSignatures ${chatId}`);
+    }
+    async toggleAntiSpam(chatId, enabled) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Aggressive anti-spam is only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Aggressive anti-spam is only available for supergroups, not broadcast channels");
+            }
+            await this.client?.invoke(new Api.channels.ToggleAntiSpam({ channel: entity, enabled }));
+        }, `toggleAntiSpam ${chatId}`);
+    }
+    async toggleForumMode(chatId, enabled) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Forum mode is only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Forum mode is only available for supergroups, not broadcast channels");
+            }
+            await this.client?.invoke(new Api.channels.ToggleForum({ channel: entity, enabled }));
+        }, `toggleForumMode ${chatId}`);
+    }
+    async togglePrehistoryHidden(chatId, hidden) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Prehistory visibility is only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Prehistory visibility is only available for supergroups, not broadcast channels");
+            }
+            await this.client?.invoke(new Api.channels.TogglePreHistoryHidden({ channel: entity, enabled: hidden }));
+        }, `togglePrehistoryHidden ${chatId}`);
+    }
+    async setChatAvailableReactions(chatId, reactions) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel) && !(entity instanceof Api.Chat)) {
+                throw new Error("Chat reactions can only be configured for groups, supergroups, and channels");
+            }
+            let availableReactions;
+            if (reactions.type === "all") {
+                availableReactions = new Api.ChatReactionsAll({ allowCustom: reactions.allowCustom });
+            }
+            else if (reactions.type === "none") {
+                availableReactions = new Api.ChatReactionsNone();
+            }
+            else {
+                if (reactions.emoji.length === 0) {
+                    throw new Error('reactions.emoji must be non-empty when type is "some" (use type:"none" to disable)');
+                }
+                availableReactions = new Api.ChatReactionsSome({
+                    reactions: reactions.emoji.map((emoticon) => new Api.ReactionEmoji({ emoticon })),
+                });
+            }
+            await this.client?.invoke(new Api.messages.SetChatAvailableReactions({ peer: entity, availableReactions }));
+        }, `setChatAvailableReactions ${chatId}`);
+    }
+    async approveChatJoinRequest(chatId, userId, approved) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Join request approval is only supported for supergroups and channels, not basic groups");
+            }
+            const user = await this.client?.getEntity(userId);
+            if (!(user instanceof Api.User)) {
+                throw new Error("Target is not a user");
+            }
+            const inputUser = new Api.InputUser({ userId: user.id, accessHash: user.accessHash ?? bigInt.zero });
+            await this.client?.invoke(new Api.messages.HideChatJoinRequest({ peer: entity, userId: inputUser, approved }));
+        }, `approveChatJoinRequest ${chatId}/${userId}`);
+    }
+    async getInlineBotResults(bot, chatId, query, offset) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const peer = await this.resolveChat(chatId);
+            const botEntity = await this.client?.getEntity(bot);
+            if (!(botEntity instanceof Api.User)) {
+                throw new Error(`'${bot}' is not a user/bot`);
+            }
+            if (!botEntity.bot) {
+                throw new Error(`'${bot}' is not a bot (inline queries require a bot account)`);
+            }
+            const inputBot = new Api.InputUser({
+                userId: botEntity.id,
+                accessHash: botEntity.accessHash ?? bigInt.zero,
+            });
+            const result = await this.client?.invoke(new Api.messages.GetInlineBotResults({
+                bot: inputBot,
+                peer,
+                query,
+                offset: offset ?? "",
+            }));
+            if (!result)
+                throw new Error("No inline bot results returned");
+            return {
+                queryId: result.queryId.toString(),
+                nextOffset: result.nextOffset,
+                cacheTime: result.cacheTime,
+                gallery: result.gallery === true,
+                results: result.results.map((r) => {
+                    if (r instanceof Api.BotInlineResult) {
+                        return { id: r.id, type: r.type, title: r.title, description: r.description, url: r.url };
+                    }
+                    const mr = r;
+                    return { id: mr.id, type: mr.type, title: mr.title, description: mr.description };
+                }),
+            };
+        }, `getInlineBotResults via ${bot}`);
+    }
+    async sendInlineBotResult(chatId, queryId, resultId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const peer = await this.resolveChat(chatId);
+            const randomId = bigInt(Math.floor(Math.random() * 1e15));
+            const replyTo = options?.replyTo ? new Api.InputReplyToMessage({ replyToMsgId: options.replyTo }) : undefined;
+            const result = await this.client?.invoke(new Api.messages.SendInlineBotResult({
+                peer,
+                queryId: bigInt(queryId),
+                id: resultId,
+                randomId,
+                ...(replyTo ? { replyTo } : {}),
+                ...(options?.silent ? { silent: true } : {}),
+                ...(options?.hideVia ? { hideVia: true } : {}),
+                ...(options?.clearDraft ? { clearDraft: true } : {}),
+            }));
+            if (!result)
+                throw new Error("No response from SendInlineBotResult");
+            if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+                for (const update of result.updates) {
+                    if (update instanceof Api.UpdateMessageID && update.randomId?.equals(randomId)) {
+                        return { messageId: update.id };
+                    }
+                }
+            }
+            if (result instanceof Api.UpdateShortSentMessage) {
+                return { messageId: result.id };
+            }
+            return { messageId: 0 };
+        }, `sendInlineBotResult ${resultId} to ${chatId}`);
+    }
+    async pressButton(chatId, messageId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            let data;
+            if (options.buttonIndex) {
+                const { row, column } = options.buttonIndex;
+                const messages = await this.client?.getMessages(entity, { ids: [messageId] });
+                const msg = messages?.[0];
+                if (!msg)
+                    throw new Error(`Message ${messageId} not found in ${chatId}`);
+                const markup = msg.replyMarkup;
+                if (!markup)
+                    throw new Error(`Message ${messageId} has no reply markup`);
+                if (!(markup instanceof Api.ReplyInlineMarkup)) {
+                    throw new Error(`Message ${messageId} reply markup is ${markup.className} (only ReplyInlineMarkup has callable buttons)`);
+                }
+                const rowEntry = markup.rows[row];
+                if (!rowEntry)
+                    throw new Error(`Row ${row} out of bounds (message has ${markup.rows.length} rows)`);
+                const button = rowEntry.buttons[column];
+                if (!button) {
+                    throw new Error(`Column ${column} out of bounds in row ${row} (row has ${rowEntry.buttons.length} buttons)`);
+                }
+                if (!(button instanceof Api.KeyboardButtonCallback)) {
+                    throw new Error(`Button at (${row},${column}) is ${button.className}, not callable — use the appropriate tool for URL/switch-inline/game buttons`);
+                }
+                if (button.requiresPassword) {
+                    throw new Error(`Button at (${row},${column}) requires 2FA password confirmation — not supported by telegram-press-button`);
+                }
+                data = Buffer.from(button.data);
+            }
+            else if (options.data !== undefined) {
+                data = Buffer.from(options.data, "base64");
+            }
+            else {
+                throw new Error("Either buttonIndex or data must be provided");
+            }
+            const answer = await this.client?.invoke(new Api.messages.GetBotCallbackAnswer({
+                peer: entity,
+                msgId: messageId,
+                data,
+            }));
+            if (!answer)
+                throw new Error("No callback answer returned");
+            return {
+                alert: answer.alert,
+                hasUrl: answer.hasUrl,
+                nativeUi: answer.nativeUi,
+                message: answer.message,
+                url: answer.url,
+                cacheTime: answer.cacheTime,
+            };
+        }, `pressButton ${chatId}/${messageId}`);
+    }
+    async getMessageButtons(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            const messages = await this.client?.getMessages(entity, { ids: [messageId] });
+            const msg = messages?.[0];
+            if (!msg)
+                throw new Error(`Message ${messageId} not found in ${chatId}`);
+            const markup = msg.replyMarkup;
+            if (!markup) {
+                return { markupType: "none", buttons: [] };
+            }
+            if (!(markup instanceof Api.ReplyInlineMarkup) && !(markup instanceof Api.ReplyKeyboardMarkup)) {
+                return { markupType: markup.className, buttons: [] };
+            }
+            const buttons = [];
+            markup.rows.forEach((rowEntry, row) => {
+                rowEntry.buttons.forEach((button, col) => {
+                    buttons.push(describeKeyboardButton(button, row, col));
+                });
+            });
+            return { markupType: markup.className, buttons };
+        }, `getMessageButtons ${chatId}/${messageId}`);
+    }
+    async getBroadcastStats(chatId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Broadcast stats are only available for channels");
+            }
+            if (entity.megagroup) {
+                throw new Error("Broadcast stats are only available for broadcast channels, not supergroups (use telegram-get-megagroup-stats)");
+            }
+            let result;
+            try {
+                const response = await this.client?.invoke(new Api.stats.GetBroadcastStats({ channel: entity, dark: options?.dark }));
+                if (!response) {
+                    throw new Error("channel has no stats (may require Telegram Premium admin)");
+                }
+                result = response;
+            }
+            catch (e) {
+                const msg = e.message ?? String(e);
+                if (/CHAT_ADMIN_REQUIRED|ADMIN_RANK_INVALID/i.test(msg)) {
+                    throw new Error("Access denied: channel stats require admin rights (and may require Telegram Premium)");
+                }
+                if (/STATS_UNAVAILABLE|BROADCAST_REQUIRED|PARTICIPANTS_TOO_FEW/i.test(msg)) {
+                    throw new Error("channel has no stats (may require Telegram Premium admin)");
+                }
+                throw e;
+            }
+            return summarizeBroadcastStats(result, options?.includeGraphs === true);
+        }, `getBroadcastStats ${chatId}`);
+    }
+    async getMegagroupStats(chatId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Megagroup stats are only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Megagroup stats are only available for supergroups, not broadcast channels (use telegram-get-broadcast-stats)");
+            }
+            let result;
+            try {
+                const response = await this.client?.invoke(new Api.stats.GetMegagroupStats({ channel: entity, dark: options?.dark }));
+                if (!response) {
+                    throw new Error("supergroup has no stats yet (needs more activity/members)");
+                }
+                result = response;
+            }
+            catch (e) {
+                const msg = e.message ?? String(e);
+                if (/CHAT_ADMIN_REQUIRED|ADMIN_RANK_INVALID/i.test(msg)) {
+                    throw new Error("Access denied: supergroup stats require admin rights");
+                }
+                if (/STATS_UNAVAILABLE|PARTICIPANTS_TOO_FEW|MEGAGROUP_REQUIRED/i.test(msg)) {
+                    throw new Error("supergroup has no stats yet (needs more activity/members)");
+                }
+                throw e;
+            }
+            return summarizeMegagroupStats(result, options?.includeGraphs === true);
+        }, `getMegagroupStats ${chatId}`, { throwOnFloodWait: true });
+    }
+    async getUpdatesState() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const state = await this.client?.invoke(new Api.updates.GetState());
+            if (!state)
+                throw new Error("updates.GetState returned no state");
+            return {
+                pts: state.pts,
+                qts: state.qts,
+                date: state.date,
+                seq: state.seq,
+                unreadCount: state.unreadCount,
+            };
+        }, "getUpdatesState");
+    }
+    async getUpdates(cursor) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const ptsLimit = Math.min(cursor.ptsLimit ?? 100, 1000);
+        const ptsTotalLimit = Math.min(cursor.ptsTotalLimit ?? 1000, 1000);
+        return this.rateLimiter.execute(async () => {
+            const diff = await this.client?.invoke(new Api.updates.GetDifference({
+                pts: cursor.pts,
+                date: cursor.date,
+                qts: cursor.qts,
+                ptsLimit,
+                ptsTotalLimit,
+            }));
+            if (!diff)
+                throw new Error("updates.GetDifference returned nothing");
+            return summarizeUpdatesDifference(diff, cursor);
+        }, "getUpdates");
+    }
+    async getChannelUpdates(chatId, cursor) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const limit = Math.min(cursor.limit ?? 100, 1_000);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Channel updates are only available for channels/supergroups");
+            }
+            const diff = await this.client?.invoke(new Api.updates.GetChannelDifference({
+                channel: entity,
+                filter: new Api.ChannelMessagesFilterEmpty(),
+                pts: cursor.pts,
+                limit,
+                force: cursor.force,
+            }));
+            if (!diff)
+                throw new Error("updates.GetChannelDifference returned nothing");
+            return summarizeChannelDifference(diff, entity.id.toString(), cursor.pts);
+        }, `getChannelUpdates ${chatId}`);
+    }
     async createForumTopic(chatId, title, iconColor, iconEmojiId) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -2690,4 +2943,216 @@ export class TelegramService {
             emoji: emojiMap.get(doc.id.toString()) || "",
         }));
     }
+    async getAllStories(options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetAllStories({
+                next: options?.next,
+                hidden: options?.hidden,
+                state: options?.state,
+            }));
+            if (!response)
+                throw new Error("stories.GetAllStories returned nothing");
+            return summarizeAllStories(response);
+        }, "getAllStories");
+    }
+    async getPeerStories(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetPeerStories({ peer }));
+            if (!response)
+                throw new Error("stories.GetPeerStories returned nothing");
+            return summarizePeerStories(response.stories);
+        }, `getPeerStories ${chatId}`);
+    }
+    async getStoriesById(chatId, ids) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetStoriesByID({ peer, id: ids }));
+            if (!response)
+                throw new Error("stories.GetStoriesByID returned nothing");
+            return summarizeStoriesById(response);
+        }, `getStoriesById ${chatId}`);
+    }
+    async getStoryViewsList(chatId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetStoryViewsList({
+                peer,
+                id: options.id,
+                q: options.q,
+                justContacts: options.justContacts,
+                reactionsFirst: options.reactionsFirst,
+                forwardsFirst: options.forwardsFirst,
+                offset: options.offset ?? "",
+                limit: options.limit ?? 50,
+            }));
+            if (!response)
+                throw new Error("stories.GetStoryViewsList returned nothing");
+            return summarizeStoryViewsList(response);
+        }, `getStoryViewsList ${chatId}/${options.id}`);
+    }
+    async getMyBoosts() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.premium.GetMyBoosts());
+            if (!response)
+                throw new Error("premium.GetMyBoosts returned nothing");
+            return summarizeMyBoosts(response);
+        }, "getMyBoosts");
+    }
+    async getBoostsStatus(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.premium.GetBoostsStatus({ peer }));
+            if (!response)
+                throw new Error("premium.GetBoostsStatus returned nothing");
+            return summarizeBoostsStatus(response);
+        }, `getBoostsStatus ${chatId}`);
+    }
+    async getBoostsList(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.premium.GetBoostsList({
+                peer,
+                gifts: options.gifts,
+                offset: options.offset ?? "",
+                limit: options.limit ?? 50,
+            }));
+            if (!response)
+                throw new Error("premium.GetBoostsList returned nothing");
+            return summarizeBoostsList(response);
+        }, `getBoostsList ${chatId}`);
+    }
+    async getBusinessChatLinks() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.account.GetBusinessChatLinks());
+            if (!response)
+                throw new Error("account.GetBusinessChatLinks returned nothing");
+            return summarizeBusinessChatLinks(response);
+        }, "getBusinessChatLinks");
+    }
+    async getGroupCall(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const call = await this.resolveInputGroupCall(chatId);
+            const response = await this.client?.invoke(new Api.phone.GetGroupCall({ call, limit: options.limit ?? 0 }));
+            if (!response)
+                throw new Error("phone.GetGroupCall returned nothing");
+            return summarizeGroupCall(response);
+        }, `getGroupCall ${chatId}`);
+    }
+    async getGroupCallParticipants(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const call = await this.resolveInputGroupCall(chatId);
+            const ids = [];
+            for (const id of options.ids ?? []) {
+                ids.push(await this.resolvePeer(id));
+            }
+            const response = await this.client?.invoke(new Api.phone.GetGroupParticipants({
+                call,
+                ids,
+                sources: options.sources ?? [],
+                offset: options.offset ?? "",
+                limit: options.limit ?? 100,
+            }));
+            if (!response)
+                throw new Error("phone.GetGroupParticipants returned nothing");
+            return summarizeGroupCallParticipants(response);
+        }, `getGroupCallParticipants ${chatId}`);
+    }
+    async getStarsStatus(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.payments.GetStarsStatus({ peer }));
+            if (!response)
+                throw new Error("payments.GetStarsStatus returned nothing");
+            return summarizeStarsStatus(response);
+        }, `getStarsStatus ${chatId}`);
+    }
+    async getStarsTransactions(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.payments.GetStarsTransactions({
+                peer,
+                inbound: options.inbound,
+                outbound: options.outbound,
+                ascending: options.ascending,
+                subscriptionId: options.subscriptionId,
+                offset: options.offset ?? "",
+                limit: options.limit ?? 50,
+            }));
+            if (!response)
+                throw new Error("payments.GetStarsTransactions returned nothing");
+            return summarizeStarsStatus(response);
+        }, `getStarsTransactions ${chatId}`);
+    }
+    async getQuickReplies(hash) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.messages.GetQuickReplies({ hash: hash ? bigInt(hash) : bigInt(0) }));
+            if (!response)
+                throw new Error("messages.GetQuickReplies returned nothing");
+            return summarizeQuickReplies(response);
+        }, "getQuickReplies");
+    }
+    async getQuickReplyMessages(shortcutId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.messages.GetQuickReplyMessages({
+                shortcutId,
+                id: options.ids,
+                hash: options.hash ? bigInt(options.hash) : bigInt(0),
+            }));
+            if (!response)
+                throw new Error("messages.GetQuickReplyMessages returned nothing");
+            return summarizeQuickReplyMessages(response);
+        }, `getQuickReplyMessages ${shortcutId}`);
+    }
+    async resolveInputGroupCall(chatId) {
+        const entity = await this.resolveChat(chatId);
+        let call;
+        if (entity instanceof Api.Channel) {
+            const full = await this.client?.invoke(new Api.channels.GetFullChannel({ channel: entity }));
+            if (full?.fullChat instanceof Api.ChannelFull) {
+                call = full.fullChat.call;
+            }
+        }
+        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) {
+                call = full.fullChat.call;
+            }
+        }
+        else {
+            throw new Error("Group calls are only available for groups/supergroups/channels");
+        }
+        if (!call) {
+            throw new Error(`No active group call in chat ${chatId}`);
+        }
+        return call;
+    }
 }