@overpod/mcp-telegram 1.24.1 → 1.26.0

package/dist/telegram-client.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { chmod, readFile, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -44,6 +44,875 @@ 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;
+}
+function absValue(v) {
+    return { current: v?.current ?? 0, previous: v?.previous ?? 0 };
+}
+function compactGraph(g) {
+    if (g instanceof Api.StatsGraphAsync)
+        return { type: "async", token: g.token };
+    if (g instanceof Api.StatsGraphError)
+        return { type: "error", error: g.error };
+    if (g instanceof Api.StatsGraph) {
+        let parsed = g.json?.data;
+        if (typeof parsed === "string") {
+            try {
+                parsed = JSON.parse(parsed);
+            }
+            catch {
+                // leave raw string
+            }
+        }
+        return { type: "data", data: parsed, zoomToken: g.zoomToken };
+    }
+    const any = g;
+    if (typeof any.token === "string")
+        return { type: "async", token: any.token };
+    if (typeof any.error === "string")
+        return { type: "error", error: any.error };
+    return { type: "data", data: any.json?.data, zoomToken: any.zoomToken };
+}
+export function summarizeMegagroupStats(stats, includeGraphs) {
+    const summary = {
+        period: {
+            minDate: stats.period?.minDate ?? 0,
+            maxDate: stats.period?.maxDate ?? 0,
+        },
+        members: absValue(stats.members),
+        messages: absValue(stats.messages),
+        viewers: absValue(stats.viewers),
+        posters: absValue(stats.posters),
+        topPosters: (stats.topPosters ?? []).map((p) => ({
+            userId: p.userId?.toString() ?? "",
+            messages: p.messages,
+            avgChars: p.avgChars,
+        })),
+        topAdmins: (stats.topAdmins ?? []).map((a) => ({
+            userId: a.userId?.toString() ?? "",
+            deleted: a.deleted,
+            kicked: a.kicked,
+            banned: a.banned,
+        })),
+        topInviters: (stats.topInviters ?? []).map((i) => ({
+            userId: i.userId?.toString() ?? "",
+            invitations: i.invitations,
+        })),
+    };
+    if (includeGraphs) {
+        summary.graphs = {
+            growth: compactGraph(stats.growthGraph),
+            members: compactGraph(stats.membersGraph),
+            newMembersBySource: compactGraph(stats.newMembersBySourceGraph),
+            languages: compactGraph(stats.languagesGraph),
+            messages: compactGraph(stats.messagesGraph),
+            actions: compactGraph(stats.actionsGraph),
+            topHours: compactGraph(stats.topHoursGraph),
+            weekdays: compactGraph(stats.weekdaysGraph),
+        };
+    }
+    return summary;
+}
+export function summarizeBroadcastStats(stats, includeGraphs) {
+    const enabled = stats.enabledNotifications;
+    const part = enabled?.part ?? 0;
+    const total = enabled?.total ?? 0;
+    const percent = total > 0 ? (part / total) * 100 : 0;
+    const summary = {
+        period: {
+            minDate: stats.period?.minDate ?? 0,
+            maxDate: stats.period?.maxDate ?? 0,
+        },
+        followers: absValue(stats.followers),
+        viewsPerPost: absValue(stats.viewsPerPost),
+        sharesPerPost: absValue(stats.sharesPerPost),
+        reactionsPerPost: absValue(stats.reactionsPerPost),
+        viewsPerStory: absValue(stats.viewsPerStory),
+        sharesPerStory: absValue(stats.sharesPerStory),
+        reactionsPerStory: absValue(stats.reactionsPerStory),
+        enabledNotifications: { part, total, percent },
+        recentPostsInteractions: (stats.recentPostsInteractions ?? []).map((p) => {
+            if (p instanceof Api.PostInteractionCountersStory) {
+                return {
+                    kind: "story",
+                    storyId: p.storyId,
+                    views: p.views,
+                    forwards: p.forwards,
+                    reactions: p.reactions,
+                };
+            }
+            const m = p;
+            return {
+                kind: "message",
+                msgId: m.msgId,
+                views: m.views,
+                forwards: m.forwards,
+                reactions: m.reactions,
+            };
+        }),
+    };
+    if (includeGraphs) {
+        summary.graphs = {
+            growth: compactGraph(stats.growthGraph),
+            followers: compactGraph(stats.followersGraph),
+            mute: compactGraph(stats.muteGraph),
+            topHours: compactGraph(stats.topHoursGraph),
+            interactions: compactGraph(stats.interactionsGraph),
+            ivInteractions: compactGraph(stats.ivInteractionsGraph),
+            viewsBySource: compactGraph(stats.viewsBySourceGraph),
+            newFollowersBySource: compactGraph(stats.newFollowersBySourceGraph),
+            languages: compactGraph(stats.languagesGraph),
+            reactionsByEmotion: compactGraph(stats.reactionsByEmotionGraph),
+            storyInteractions: compactGraph(stats.storyInteractionsGraph),
+            storyReactionsByEmotion: compactGraph(stats.storyReactionsByEmotionGraph),
+        };
+    }
+    return summary;
+}
+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 function describeKeyboardButton(button, row, col) {
+    const base = {
+        row,
+        col,
+        type: button.className,
+        label: "text" in button && typeof button.text === "string" ? button.text : "",
+    };
+    if (button instanceof Api.KeyboardButtonCallback) {
+        base.data = Buffer.from(button.data).toString("base64");
+        if (button.requiresPassword)
+            base.requiresPassword = true;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUrl) {
+        base.url = button.url;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUrlAuth) {
+        base.url = button.url;
+        base.buttonId = button.buttonId;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonSwitchInline) {
+        base.switchQuery = button.query;
+        base.samePeer = Boolean(button.samePeer);
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonWebView || button instanceof Api.KeyboardButtonSimpleWebView) {
+        base.url = button.url;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUserProfile) {
+        base.userId = button.userId?.toString();
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonRequestPoll) {
+        if (button.quiz)
+            base.quiz = true;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonRequestPeer) {
+        base.buttonId = button.buttonId;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonCopy) {
+        base.copyText = button.copyText;
+        return base;
+    }
+    return base;
+}
+export function peerToCompact(peer) {
+    if (!peer)
+        return undefined;
+    if (peer instanceof Api.PeerUser)
+        return { kind: "user", id: peer.userId.toString() };
+    if (peer instanceof Api.PeerChat)
+        return { kind: "chat", id: peer.chatId.toString() };
+    if (peer instanceof Api.PeerChannel)
+        return { kind: "channel", id: peer.channelId.toString() };
+    return undefined;
+}
+function summarizeMessageForUpdates(msg) {
+    if (msg instanceof Api.MessageEmpty)
+        return null;
+    const peer = peerToCompact(msg.peerId);
+    if (!peer)
+        return null;
+    const fromId = peerToCompact(msg.fromId);
+    const date = msg.date ?? 0;
+    if (msg instanceof Api.Message) {
+        return { id: msg.id, peer, fromId, date, text: msg.message ?? "", isService: false };
+    }
+    if (msg instanceof Api.MessageService) {
+        return {
+            id: msg.id,
+            peer,
+            fromId,
+            date,
+            text: `[${msg.action?.className ?? "service"}]`,
+            isService: true,
+        };
+    }
+    return null;
+}
+function collectDeletedMessageIds(updates) {
+    const out = [];
+    for (const u of updates) {
+        if (u instanceof Api.UpdateDeleteMessages) {
+            out.push({ messageIds: u.messages });
+        }
+        else if (u instanceof Api.UpdateDeleteChannelMessages) {
+            out.push({
+                peer: { kind: "channel", id: u.channelId.toString() },
+                messageIds: u.messages,
+            });
+        }
+    }
+    return out;
+}
+export function summarizeUpdatesDifference(diff, cursor) {
+    if (diff instanceof Api.updates.DifferenceEmpty) {
+        return {
+            state: { pts: cursor.pts, qts: cursor.qts, date: diff.date, seq: diff.seq },
+            isFinal: true,
+            newMessages: [],
+            deletedMessageIds: [],
+            otherUpdates: [],
+        };
+    }
+    if (diff instanceof Api.updates.DifferenceTooLong) {
+        return {
+            state: { pts: diff.pts, qts: cursor.qts, date: cursor.date, seq: 0 },
+            isFinal: true,
+            newMessages: [],
+            deletedMessageIds: [],
+            otherUpdates: [],
+            fallback: {
+                kind: "tooLong",
+                suggestedAction: "gap too large — call telegram-read-messages per chat or telegram-get-state to resync",
+            },
+        };
+    }
+    const isFinal = diff instanceof Api.updates.Difference;
+    const state = isFinal
+        ? diff.state
+        : diff.intermediateState;
+    const newMessages = (diff.newMessages ?? [])
+        .map(summarizeMessageForUpdates)
+        .filter((m) => m !== null);
+    const otherUpdates = diff.otherUpdates ?? [];
+    return {
+        state: {
+            pts: state.pts,
+            qts: state.qts,
+            date: state.date,
+            seq: state.seq,
+            unreadCount: state.unreadCount,
+        },
+        isFinal,
+        newMessages,
+        deletedMessageIds: collectDeletedMessageIds(otherUpdates),
+        otherUpdates: otherUpdates.map((u) => ({ type: u.className })),
+    };
+}
+export function summarizeChannelDifference(diff, channelId, fallbackPts) {
+    if (diff instanceof Api.updates.ChannelDifferenceEmpty) {
+        return {
+            channelId,
+            pts: diff.pts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: [],
+            otherUpdates: [],
+        };
+    }
+    if (diff instanceof Api.updates.ChannelDifferenceTooLong) {
+        const freshPts = diff.dialog instanceof Api.Dialog ? (diff.dialog.pts ?? fallbackPts) : fallbackPts;
+        return {
+            channelId,
+            pts: freshPts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: (diff.messages ?? [])
+                .map(summarizeMessageForUpdates)
+                .filter((m) => m !== null),
+            otherUpdates: [],
+            fallback: {
+                kind: "tooLong",
+                suggestedAction: "channel gap too large — dialog snapshot returned; call telegram-read-messages for full history",
+            },
+        };
+    }
+    if (diff instanceof Api.updates.ChannelDifference) {
+        return {
+            channelId,
+            pts: diff.pts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: (diff.newMessages ?? [])
+                .map(summarizeMessageForUpdates)
+                .filter((m) => m !== null),
+            otherUpdates: (diff.otherUpdates ?? []).map((u) => ({ type: u.className })),
+        };
+    }
+    return {
+        channelId,
+        pts: fallbackPts,
+        isFinal: false,
+        newMessages: [],
+        otherUpdates: [],
+    };
+}
+export function summarizeMyBoost(boost) {
+    const b = boost;
+    return {
+        slot: b.slot,
+        peer: peerToCompact(b.peer),
+        date: b.date,
+        expires: b.expires,
+        cooldownUntilDate: b.cooldownUntilDate,
+    };
+}
+export function summarizeMyBoosts(result) {
+    const boosts = result.myBoosts ?? [];
+    return {
+        count: boosts.length,
+        myBoosts: boosts.map(summarizeMyBoost),
+    };
+}
+export function summarizePrepaidGiveaway(g) {
+    if (g instanceof Api.PrepaidStarsGiveaway) {
+        return {
+            kind: "stars",
+            id: g.id.toString(),
+            quantity: g.quantity,
+            date: g.date,
+            stars: g.stars.toString(),
+            boosts: g.boosts,
+        };
+    }
+    const p = g;
+    return {
+        kind: "premium",
+        id: p.id.toString(),
+        quantity: p.quantity,
+        date: p.date,
+        months: p.months,
+    };
+}
+export function summarizeBoostsStatus(result) {
+    const r = result;
+    const out = {
+        level: r.level,
+        boosts: r.boosts,
+        currentLevelBoosts: r.currentLevelBoosts,
+        nextLevelBoosts: r.nextLevelBoosts,
+        giftBoosts: r.giftBoosts,
+        boostUrl: r.boostUrl,
+        myBoost: r.myBoost,
+        myBoostSlots: r.myBoostSlots,
+    };
+    if (r.premiumAudience) {
+        out.premiumAudience = { part: r.premiumAudience.part, total: r.premiumAudience.total };
+    }
+    if (r.prepaidGiveaways && r.prepaidGiveaways.length > 0) {
+        out.prepaidGiveaways = r.prepaidGiveaways.map(summarizePrepaidGiveaway);
+    }
+    return out;
+}
+export function summarizeBoost(boost) {
+    const b = boost;
+    return {
+        id: b.id,
+        userId: b.userId?.toString(),
+        date: b.date,
+        expires: b.expires,
+        gift: b.gift,
+        giveaway: b.giveaway,
+        unclaimed: b.unclaimed,
+        giveawayMsgId: b.giveawayMsgId,
+        usedGiftSlug: b.usedGiftSlug,
+        multiplier: b.multiplier,
+        stars: b.stars?.toString(),
+    };
+}
+export function summarizeBoostsList(result) {
+    const r = result;
+    return {
+        count: r.count,
+        boosts: (r.boosts ?? []).map(summarizeBoost),
+        nextOffset: r.nextOffset,
+    };
+}
+export function summarizeBusinessChatLink(link) {
+    const l = link;
+    return {
+        link: l.link,
+        message: l.message,
+        title: l.title,
+        views: l.views,
+        entityCount: l.entities?.length ?? 0,
+    };
+}
+export function summarizeBusinessChatLinks(result) {
+    const r = result;
+    const links = r.links ?? [];
+    return {
+        count: links.length,
+        links: links.map(summarizeBusinessChatLink),
+    };
+}
+export function summarizeGroupCallInfo(call) {
+    if (call instanceof Api.GroupCallDiscarded) {
+        return {
+            kind: "discarded",
+            id: call.id.toString(),
+            accessHash: call.accessHash.toString(),
+            duration: call.duration,
+        };
+    }
+    const c = call;
+    return {
+        kind: "active",
+        id: c.id.toString(),
+        accessHash: c.accessHash.toString(),
+        participantsCount: c.participantsCount,
+        title: c.title,
+        scheduleDate: c.scheduleDate,
+        recordStartDate: c.recordStartDate,
+        streamDcId: c.streamDcId,
+        unmutedVideoCount: c.unmutedVideoCount,
+        unmutedVideoLimit: c.unmutedVideoLimit,
+        version: c.version,
+        joinMuted: c.joinMuted,
+        canChangeJoinMuted: c.canChangeJoinMuted,
+        joinDateAsc: c.joinDateAsc,
+        scheduleStartSubscribed: c.scheduleStartSubscribed,
+        canStartVideo: c.canStartVideo,
+        recordVideoActive: c.recordVideoActive,
+        rtmpStream: c.rtmpStream,
+        listenersHidden: c.listenersHidden,
+    };
+}
+export function summarizeGroupCallParticipant(p) {
+    const gp = p;
+    return {
+        peer: peerToCompact(gp.peer),
+        date: gp.date,
+        activeDate: gp.activeDate,
+        source: gp.source,
+        volume: gp.volume,
+        muted: gp.muted,
+        left: gp.left,
+        canSelfUnmute: gp.canSelfUnmute,
+        justJoined: gp.justJoined,
+        self: gp.self,
+        mutedByYou: gp.mutedByYou,
+        volumeByAdmin: gp.volumeByAdmin,
+        videoJoined: gp.videoJoined,
+        about: gp.about,
+        raiseHandRating: gp.raiseHandRating?.toString(),
+        hasVideo: gp.video ? true : undefined,
+        hasPresentation: gp.presentation ? true : undefined,
+    };
+}
+export function summarizeGroupCall(result) {
+    const r = result;
+    return {
+        call: summarizeGroupCallInfo(r.call),
+        participants: (r.participants ?? []).map(summarizeGroupCallParticipant),
+        participantsNextOffset: r.participantsNextOffset || undefined,
+    };
+}
+export function summarizeGroupCallParticipants(result) {
+    const r = result;
+    return {
+        count: r.count,
+        participants: (r.participants ?? []).map(summarizeGroupCallParticipant),
+        nextOffset: r.nextOffset || undefined,
+        version: r.version,
+    };
+}
+export function summarizeStarsAmount(amount) {
+    const a = amount;
+    return { amount: a.amount.toString(), nanos: a.nanos };
+}
+export function summarizeStarsTransactionPeer(peer) {
+    if (peer instanceof Api.StarsTransactionPeerAppStore)
+        return { kind: "appStore" };
+    if (peer instanceof Api.StarsTransactionPeerPlayMarket)
+        return { kind: "playMarket" };
+    if (peer instanceof Api.StarsTransactionPeerPremiumBot)
+        return { kind: "premiumBot" };
+    if (peer instanceof Api.StarsTransactionPeerFragment)
+        return { kind: "fragment" };
+    if (peer instanceof Api.StarsTransactionPeerAds)
+        return { kind: "ads" };
+    if (peer instanceof Api.StarsTransactionPeerAPI)
+        return { kind: "api" };
+    if (peer instanceof Api.StarsTransactionPeer)
+        return { kind: "peer", peer: peerToCompact(peer.peer) };
+    return { kind: "unsupported" };
+}
+export function summarizeStarsTransaction(tx) {
+    const t = tx;
+    return {
+        id: t.id,
+        stars: summarizeStarsAmount(t.stars),
+        date: t.date,
+        peer: summarizeStarsTransactionPeer(t.peer),
+        refund: t.refund,
+        pending: t.pending,
+        failed: t.failed,
+        gift: t.gift,
+        reaction: t.reaction,
+        title: t.title,
+        description: t.description,
+        msgId: t.msgId,
+        subscriptionPeriod: t.subscriptionPeriod,
+        giveawayPostId: t.giveawayPostId,
+        transactionDate: t.transactionDate,
+        transactionUrl: t.transactionUrl,
+    };
+}
+export function summarizeStarsSubscription(sub) {
+    const s = sub;
+    const pricing = s.pricing;
+    return {
+        id: s.id,
+        peer: peerToCompact(s.peer),
+        untilDate: s.untilDate,
+        pricing: { period: pricing.period, amount: pricing.amount.toString() },
+        canceled: s.canceled,
+        canRefulfill: s.canRefulfill,
+        missingBalance: s.missingBalance,
+        botCanceled: s.botCanceled,
+        chatInviteHash: s.chatInviteHash,
+        title: s.title,
+        invoiceSlug: s.invoiceSlug,
+    };
+}
+export function summarizeQuickReply(reply) {
+    const r = reply;
+    return {
+        shortcutId: r.shortcutId,
+        shortcut: r.shortcut,
+        topMessage: r.topMessage,
+        count: r.count,
+    };
+}
+export function summarizeQuickReplies(result) {
+    if (result instanceof Api.messages.QuickRepliesNotModified) {
+        return { notModified: true };
+    }
+    const r = result;
+    return { quickReplies: r.quickReplies.map(summarizeQuickReply) };
+}
+export function summarizeQuickReplyMessage(msg) {
+    if (msg instanceof Api.MessageEmpty)
+        return null;
+    const base = msg;
+    const fromId = peerToCompact(base.fromId);
+    const replyHeader = base.replyTo;
+    const replyToMsgId = replyHeader instanceof Api.MessageReplyHeader ? replyHeader.replyToMsgId : undefined;
+    if (msg instanceof Api.Message) {
+        return {
+            id: msg.id,
+            date: msg.date,
+            text: msg.message ?? "",
+            isService: false,
+            fromId,
+            replyToMsgId,
+        };
+    }
+    if (msg instanceof Api.MessageService) {
+        return {
+            id: msg.id,
+            date: msg.date,
+            text: `[${msg.action?.className ?? "service"}]`,
+            isService: true,
+            fromId,
+        };
+    }
+    return null;
+}
+export function summarizeQuickReplyMessages(result) {
+    if (result instanceof Api.messages.MessagesNotModified) {
+        return { notModified: true, count: result.count };
+    }
+    const rawMessages = result
+        .messages;
+    const messages = rawMessages.map(summarizeQuickReplyMessage).filter((m) => m !== null);
+    const count = result instanceof Api.messages.Messages
+        ? messages.length
+        : result.count;
+    return { count, messages };
+}
+export function summarizeStarsStatus(result) {
+    const r = result;
+    const out = {
+        balance: summarizeStarsAmount(r.balance),
+        subscriptionsNextOffset: r.subscriptionsNextOffset || undefined,
+        subscriptionsMissingBalance: r.subscriptionsMissingBalance?.toString(),
+        nextOffset: r.nextOffset || undefined,
+    };
+    if (r.subscriptions && r.subscriptions.length > 0) {
+        out.subscriptions = r.subscriptions.map(summarizeStarsSubscription);
+    }
+    if (r.history && r.history.length > 0) {
+        out.history = r.history.map(summarizeStarsTransaction);
+    }
+    return out;
+}
+export function summarizeStoryItem(item) {
+    if (item instanceof Api.StoryItemDeleted) {
+        return { id: item.id, kind: "deleted" };
+    }
+    if (item instanceof Api.StoryItemSkipped) {
+        return {
+            id: item.id,
+            kind: "skipped",
+            date: item.date,
+            expireDate: item.expireDate,
+            closeFriends: item.closeFriends,
+        };
+    }
+    const story = item;
+    return {
+        id: story.id,
+        kind: "active",
+        date: story.date,
+        expireDate: story.expireDate,
+        caption: story.caption,
+        mediaType: story.media?.className,
+        pinned: story.pinned,
+        public: story.public,
+        closeFriends: story.closeFriends,
+        edited: story.edited,
+        noforwards: story.noforwards,
+        fromId: peerToCompact(story.fromId),
+        viewsCount: story.views?.viewsCount,
+        reactionsCount: story.views?.reactionsCount,
+    };
+}
+export function summarizePeerStories(ps) {
+    const peer = peerToCompact(ps.peer);
+    if (!peer)
+        return null;
+    return {
+        peer,
+        maxReadId: ps.maxReadId,
+        stories: (ps.stories ?? []).map(summarizeStoryItem),
+    };
+}
+export function summarizeStoriesById(result) {
+    return {
+        count: result.count,
+        stories: (result.stories ?? []).map(summarizeStoryItem),
+        pinnedToTop: result.pinnedToTop,
+    };
+}
+export function summarizeStoryView(view) {
+    if (view instanceof Api.StoryViewPublicForward) {
+        const msg = view.message;
+        const messageId = msg instanceof Api.MessageEmpty ? undefined : msg?.id;
+        const peer = msg instanceof Api.MessageEmpty
+            ? undefined
+            : peerToCompact(msg?.peerId);
+        return {
+            kind: "publicForward",
+            messageId,
+            peer,
+            blocked: view.blocked,
+            blockedMyStoriesFrom: view.blockedMyStoriesFrom,
+        };
+    }
+    if (view instanceof Api.StoryViewPublicRepost) {
+        const story = view.story;
+        return {
+            kind: "publicRepost",
+            peer: peerToCompact(view.peerId),
+            storyId: story?.id,
+            blocked: view.blocked,
+            blockedMyStoriesFrom: view.blockedMyStoriesFrom,
+        };
+    }
+    const v = view;
+    return {
+        kind: "user",
+        userId: v.userId.toString(),
+        date: v.date,
+        reaction: v.reaction ? reactionToEmoji(v.reaction) : undefined,
+        blocked: v.blocked,
+        blockedMyStoriesFrom: v.blockedMyStoriesFrom,
+    };
+}
+export function summarizeStoryViewsList(result) {
+    const list = result;
+    return {
+        count: list.count,
+        viewsCount: list.viewsCount,
+        forwardsCount: list.forwardsCount,
+        reactionsCount: list.reactionsCount,
+        views: (list.views ?? []).map(summarizeStoryView),
+        nextOffset: list.nextOffset,
+    };
+}
+export function summarizeAllStories(result) {
+    const stealthMode = result.stealthMode
+        ? {
+            activeUntilDate: result.stealthMode.activeUntilDate,
+            cooldownUntilDate: result.stealthMode.cooldownUntilDate,
+        }
+        : undefined;
+    if (result instanceof Api.stories.AllStoriesNotModified) {
+        return {
+            modified: false,
+            state: result.state,
+            peerStories: [],
+            stealthMode,
+        };
+    }
+    const all = result;
+    const peerStories = (all.peerStories ?? [])
+        .map(summarizePeerStories)
+        .filter((p) => p !== null);
+    return {
+        modified: true,
+        state: all.state,
+        hasMore: all.hasMore,
+        count: all.count,
+        peerStories,
+        stealthMode,
+    };
+}
 export class TelegramService {
     client = null;
     apiId;
@@ -52,6 +921,7 @@ export class TelegramService {
     connected = false;
     sessionPath;
     rateLimiter = new RateLimiter();
+    lastTypingAt = new Map();
     lastError = "";
     get sessionDir() {
         return dirname(this.sessionPath);
@@ -311,24 +1181,12 @@ export class TelegramService {
         return this.rateLimiter.execute(async () => {
             const resolved = await this.resolvePeer(chatId);
             if (topicId) {
-                const peer = await this.client?.getInputEntity(resolved);
-                const result = await this.client?.invoke(new Api.messages.SendMessage({
-                    peer,
+                return await this.client?.sendMessage(resolved, {
                     message: text,
-                    randomId: bigInt(Math.floor(Math.random() * 1e15)),
-                    replyTo: new Api.InputReplyToMessage({
-                        replyToMsgId: replyTo ?? topicId,
-                        topMsgId: topicId,
-                    }),
-                }));
-                if (result instanceof Api.UpdateShortSentMessage)
-                    return result;
-                if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
-                    const msgUpdate = result.updates.find((u) => u instanceof Api.UpdateNewMessage);
-                    if (msgUpdate?.message instanceof Api.Message)
-                        return msgUpdate.message;
-                }
-                return undefined;
+                    topMsgId: topicId,
+                    ...(replyTo ? { replyTo } : {}),
+                    ...(parseMode ? { parseMode: parseMode === "html" ? "html" : "md" } : {}),
+                });
             }
             return await this.client?.sendMessage(resolved, {
                 message: text,
@@ -386,7 +1244,14 @@ export class TelegramService {
             return "image/png";
         if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
             return "image/gif";
-        if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46)
+        if (buffer[0] === 0x52 &&
+            buffer[1] === 0x49 &&
+            buffer[2] === 0x46 &&
+            buffer[3] === 0x46 &&
+            buffer[8] === 0x57 &&
+            buffer[9] === 0x45 &&
+            buffer[10] === 0x42 &&
+            buffer[11] === 0x50)
             return "image/webp";
         // Fall back to document mimeType
         const m = media;
@@ -526,28 +1391,6 @@ export class TelegramService {
             throw new Error(NOT_CONNECTED_ERROR);
         await this.client.markAsRead(chatId);
     }
-    static TYPING_ACTIONS = {
-        typing: () => new Api.SendMessageTypingAction(),
-        cancel: () => new Api.SendMessageCancelAction(),
-        record_video: () => new Api.SendMessageRecordVideoAction(),
-        upload_video: () => new Api.SendMessageUploadVideoAction({ progress: 0 }),
-        record_audio: () => new Api.SendMessageRecordAudioAction(),
-        upload_audio: () => new Api.SendMessageUploadAudioAction({ progress: 0 }),
-        upload_photo: () => new Api.SendMessageUploadPhotoAction({ progress: 0 }),
-        upload_document: () => new Api.SendMessageUploadDocumentAction({ progress: 0 }),
-        choose_sticker: () => new Api.SendMessageChooseStickerAction(),
-        game_play: () => new Api.SendMessageGamePlayAction(),
-    };
-    async setTyping(chatId, action = "typing") {
-        if (!this.client || !this.connected)
-            throw new Error(NOT_CONNECTED_ERROR);
-        const factory = TelegramService.TYPING_ACTIONS[action];
-        if (!factory)
-            throw new Error(`Unknown typing action: ${action}. Valid: ${Object.keys(TelegramService.TYPING_ACTIONS).join(", ")}`);
-        const resolved = await this.resolvePeer(chatId);
-        const peer = await this.client.getInputEntity(resolved);
-        await this.client.invoke(new Api.messages.SetTyping({ peer, action: factory() }));
-    }
     async getMessageById(chatId, messageId) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -588,59 +1431,281 @@ export class TelegramService {
             await this.client?.deleteMessages(resolved, messageIds, { revoke: true });
         }, `deleteMessages in ${chatId}`);
     }
-    /**
-     * 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)
+    async getScheduledMessages(chatId) {
+        if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
-        // First try direct resolve (numeric ID, username, phone)
-        try {
-            return await this.client.getEntity(chatId);
-        }
-        catch {
-            // Fall through to dialog search
-        }
-        // Search dialogs by display name
-        const dialogs = await this.client.getDialogs({ limit: 100 });
-        const query = chatId.toLowerCase();
-        // Exact match first
-        const exact = dialogs.find((d) => d.title?.toLowerCase() === query);
-        if (exact?.entity)
-            return exact.entity;
-        // Partial match
-        const partial = dialogs.filter((d) => d.title?.toLowerCase().includes(query));
-        if (partial.length === 1 && 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}`);
-        }
-        throw new Error(`Cannot find chat "${chatId}". Use a numeric ID, @username, or run telegram-search-chats to find it.`);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            const result = await this.client?.invoke(new Api.messages.GetScheduledHistory({ peer, hash: bigInt(0) }));
+            if (!result || result instanceof Api.messages.MessagesNotModified)
+                return [];
+            const messages = result
+                .messages;
+            return messages
+                .filter((m) => m instanceof Api.Message)
+                .map((m) => ({
+                id: m.id,
+                date: new Date((m.date ?? 0) * 1000).toISOString(),
+                text: m.message ?? "",
+                media: this.extractMediaInfo(m.media),
+            }));
+        }, `getScheduledMessages in ${chatId}`);
     }
-    /**
-     * 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) {
-        // Numeric IDs and @usernames work directly
-        if (/^-?\d+$/.test(chatId) || chatId.startsWith("@"))
-            return chatId;
-        // Everything else — resolve via dialogs
-        return this.resolveChat(chatId);
+    async deleteScheduledMessages(chatId, messageIds) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        await this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            await this.client?.invoke(new Api.messages.DeleteScheduledMessages({ peer, id: messageIds }));
+        }, `deleteScheduledMessages in ${chatId}`);
     }
-    async getChatInfo(chatId) {
+    async getReplies(chatId, messageId, limit = 20) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
-        const entity = await this.resolveChat(chatId);
-        if (entity instanceof Api.User) {
-            const parts = [entity.firstName, entity.lastName].filter(Boolean);
-            return {
-                id: entity.id.toString(),
-                name: parts.join(" ") || "Unknown",
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            const result = await this.client?.invoke(new Api.messages.GetReplies({ peer, msgId: messageId, limit, hash: bigInt(0) }));
+            if (!result || result instanceof Api.messages.MessagesNotModified)
+                return [];
+            const messages = result
+                .messages;
+            return Promise.all(messages
+                .filter((m) => m instanceof Api.Message)
+                .map(async (m) => ({
+                id: m.id,
+                text: m.message ?? "",
+                sender: await this.resolveSenderName(m.senderId),
+                date: new Date((m.date ?? 0) * 1000).toISOString(),
+                media: this.extractMediaInfo(m.media),
+                reactions: this.extractReactions(m.reactions),
+            })));
+        }, `getReplies for ${messageId} in ${chatId}`);
+    }
+    async getMessageLink(chatId, messageId, thread = false) {
+        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("Message links are only available for channels and supergroups");
+            }
+            const result = await this.client?.invoke(new Api.channels.ExportMessageLink({ channel: entity, id: messageId, thread }));
+            if (!result)
+                throw new Error("Failed to export message link");
+            return result.link;
+        }, `getMessageLink for ${messageId} in ${chatId}`);
+    }
+    async getUnreadMentions(chatId, limit = 20) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            const result = await this.client?.invoke(new Api.messages.GetUnreadMentions({
+                peer,
+                offsetId: 0,
+                addOffset: 0,
+                limit,
+                maxId: 0,
+                minId: 0,
+            }));
+            if (!result || result instanceof Api.messages.MessagesNotModified)
+                return [];
+            const typedResult = result;
+            const messages = typedResult.messages;
+            const items = await Promise.all(messages
+                .filter((m) => m instanceof Api.Message)
+                .map(async (m) => ({
+                id: m.id,
+                text: m.message ?? "",
+                sender: await this.resolveSenderName(m.senderId),
+                date: new Date((m.date ?? 0) * 1000).toISOString(),
+                media: this.extractMediaInfo(m.media),
+                reactions: this.extractReactions(m.reactions),
+            })));
+            // Only mark all as read when we received the complete set; if truncated, marking all
+            // would silently clear mentions the caller hasn't seen yet.
+            const totalCount = "count" in typedResult ? typedResult.count : items.length;
+            if (items.length > 0 && items.length >= totalCount) {
+                try {
+                    await this.client?.invoke(new Api.messages.ReadMentions({ peer }));
+                }
+                catch {
+                    // best-effort; don't discard fetched items on mark-read failure
+                }
+            }
+            return items;
+        }, `getUnreadMentions in ${chatId}`);
+    }
+    async getUnreadReactions(chatId, limit = 20) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            const result = await this.client?.invoke(new Api.messages.GetUnreadReactions({
+                peer,
+                offsetId: 0,
+                addOffset: 0,
+                limit,
+                maxId: 0,
+                minId: 0,
+            }));
+            if (!result || result instanceof Api.messages.MessagesNotModified)
+                return [];
+            const typedResult = result;
+            const messages = typedResult.messages;
+            const items = await Promise.all(messages
+                .filter((m) => m instanceof Api.Message)
+                .map(async (m) => ({
+                id: m.id,
+                text: m.message ?? "",
+                sender: await this.resolveSenderName(m.senderId),
+                date: new Date((m.date ?? 0) * 1000).toISOString(),
+                media: this.extractMediaInfo(m.media),
+                reactions: this.extractReactions(m.reactions),
+            })));
+            // Only mark all as read when we received the complete set; if truncated, marking all
+            // would silently clear reactions the caller hasn't seen yet.
+            const totalCount = "count" in typedResult ? typedResult.count : items.length;
+            if (items.length > 0 && items.length >= totalCount) {
+                try {
+                    await this.client?.invoke(new Api.messages.ReadReactions({ peer }));
+                }
+                catch {
+                    // best-effort; don't discard fetched items on mark-read failure
+                }
+            }
+            return items;
+        }, `getUnreadReactions in ${chatId}`);
+    }
+    async translateText(chatId, messageIds, toLang) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            const result = await this.client?.invoke(new Api.messages.TranslateText({ peer, id: messageIds, toLang }));
+            if (!result)
+                return [];
+            return result.result.map((t) => (t instanceof Api.TextWithEntities ? t.text : ""));
+        }, `translateText in ${chatId}`);
+    }
+    async sendTyping(chatId, action = "typing") {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            let stamped = false;
+            if (action !== "cancel") {
+                const now = Date.now();
+                const last = this.lastTypingAt.get(chatId) ?? 0;
+                if (now - last < 10_000)
+                    return;
+                this.lastTypingAt.set(chatId, now);
+                stamped = true;
+            }
+            try {
+                const resolved = await this.resolvePeer(chatId);
+                const peer = await this.client?.getInputEntity(resolved);
+                if (!peer)
+                    throw new Error(`Cannot resolve peer for ${chatId}`);
+                let sendAction;
+                switch (action) {
+                    case "cancel":
+                        sendAction = new Api.SendMessageCancelAction();
+                        break;
+                    case "upload_photo":
+                        sendAction = new Api.SendMessageUploadPhotoAction({ progress: 0 });
+                        break;
+                    case "upload_document":
+                        sendAction = new Api.SendMessageUploadDocumentAction({ progress: 0 });
+                        break;
+                    default:
+                        sendAction = new Api.SendMessageTypingAction();
+                }
+                await this.client?.invoke(new Api.messages.SetTyping({ peer, action: sendAction }));
+                if (action === "cancel") {
+                    this.lastTypingAt.delete(chatId);
+                }
+            }
+            catch (err) {
+                if (stamped)
+                    this.lastTypingAt.delete(chatId);
+                throw err;
+            }
+        }, `sendTyping in ${chatId}`);
+    }
+    /**
+     * 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);
+        // First try direct resolve (numeric ID, username, phone)
+        try {
+            return await this.client.getEntity(chatId);
+        }
+        catch {
+            // Fall through to dialog search
+        }
+        // Search dialogs by display name
+        const dialogs = await this.client.getDialogs({ limit: 100 });
+        const query = chatId.toLowerCase();
+        // Exact match first
+        const exact = dialogs.find((d) => d.title?.toLowerCase() === query);
+        if (exact?.entity)
+            return exact.entity;
+        // Partial match
+        const partial = dialogs.filter((d) => d.title?.toLowerCase().includes(query));
+        if (partial.length === 1 && 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}`);
+        }
+        throw new Error(`Cannot find chat "${chatId}". Use a numeric ID, @username, or run telegram-search-chats to find it.`);
+    }
+    /**
+     * 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;
+        // Everything else — resolve via dialogs
+        return this.resolveChat(chatId);
+    }
+    async getChatInfo(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const entity = await this.resolveChat(chatId);
+        if (entity instanceof Api.User) {
+            const parts = [entity.firstName, entity.lastName].filter(Boolean);
+            return {
+                id: entity.id.toString(),
+                name: parts.join(" ") || "Unknown",
                 type: "private",
                 username: entity.username ?? undefined,
                 isBot: Boolean(entity.bot),
@@ -1118,7 +2183,14 @@ export class TelegramService {
             return "image/png";
         if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
             return "image/gif";
-        if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46)
+        if (buffer[0] === 0x52 &&
+            buffer[1] === 0x49 &&
+            buffer[2] === 0x46 &&
+            buffer[3] === 0x46 &&
+            buffer[8] === 0x57 &&
+            buffer[9] === 0x45 &&
+            buffer[10] === 0x42 &&
+            buffer[11] === 0x50)
             return "image/webp";
         return "image/jpeg"; // Telegram profile photos are almost always JPEG
     }
@@ -1225,7 +2297,7 @@ export class TelegramService {
                         for (const r of list.reactions) {
                             const userId = r.peerId instanceof Api.PeerUser ? r.peerId.userId.toString() : "";
                             if (userId) {
-                                const name = await this.resolveSenderName(bigInt(Number.parseInt(userId, 10)));
+                                const name = await this.resolveSenderName(bigInt(userId));
                                 users.push({ id: userId, name });
                             }
                         }
@@ -1240,6 +2312,47 @@ export class TelegramService {
         const total = reactionsOut.reduce((sum, r) => sum + r.count, 0);
         return { reactions: reactionsOut, total };
     }
+    async setDefaultReaction(emoji) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        await this.rateLimiter.execute(async () => {
+            await this.client?.invoke(new Api.messages.SetDefaultReaction({
+                reaction: new Api.ReactionEmoji({ emoticon: emoji }),
+            }));
+        }, `setDefaultReaction ${emoji}`);
+    }
+    async getTopReactions(limit) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetTopReactions({ limit, hash: bigInt(0) }));
+            if (!result || result instanceof Api.messages.ReactionsNotModified)
+                return [];
+            const out = [];
+            for (const r of result.reactions) {
+                const emoji = reactionToEmoji(r);
+                if (emoji)
+                    out.push({ emoji });
+            }
+            return out;
+        }, "getTopReactions");
+    }
+    async getRecentReactions(limit) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetRecentReactions({ limit, hash: bigInt(0) }));
+            if (!result || result instanceof Api.messages.ReactionsNotModified)
+                return [];
+            const out = [];
+            for (const r of result.reactions) {
+                const emoji = reactionToEmoji(r);
+                if (emoji)
+                    out.push({ emoji });
+            }
+            return out;
+        }, "getRecentReactions");
+    }
     async sendScheduledMessage(chatId, text, scheduleDate, replyTo, parseMode) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -1319,7 +2432,8 @@ export class TelegramService {
     async getTopicMessages(chatId, topicId, limit = 20, offsetId) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
-        const peer = await this.client.getInputEntity(chatId);
+        const resolved = await this.resolvePeer(chatId);
+        const peer = await this.client.getInputEntity(resolved);
         const result = await this.client.invoke(new Api.messages.GetReplies({
             peer,
             msgId: topicId,
@@ -1376,10 +2490,11 @@ export class TelegramService {
         // Public channel/group by username
         const username = target.replace(/^@/, "").replace(/^https?:\/\/t\.me\//, "");
         const entity = await this.client.getEntity(username);
-        if (entity instanceof Api.Channel || entity instanceof Api.Chat) {
-            await this.client.invoke(new Api.channels.JoinChannel({
-                channel: entity,
-            }));
+        if (entity instanceof Api.Chat) {
+            throw new Error("Basic groups cannot be joined by username; use an invite link instead.");
+        }
+        if (entity instanceof Api.Channel) {
+            await this.client.invoke(new Api.channels.JoinChannel({ channel: entity }));
             return {
                 id: entity.id.toString(),
                 title: entity.title ?? "Unknown",
@@ -1563,7 +2678,7 @@ export class TelegramService {
             await this.client.invoke(new Api.messages.EditChatAbout({ peer: entity, about: options.description }));
         }
         if (options.photoPath) {
-            const fileData = readFileSync(options.photoPath);
+            const fileData = await readFile(options.photoPath);
             const uploaded = await this.client.uploadFile({
                 file: new CustomFile(options.photoPath, fileData.length, options.photoPath, fileData),
                 workers: 1,
@@ -1654,6 +2769,571 @@ export class TelegramService {
             settings: new Api.InputPeerNotifySettings({ muteUntil }),
         }));
     }
+    async archiveChat(chatId, archive) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            await this.client?.invoke(new Api.folders.EditPeerFolders({
+                folderPeers: [new Api.InputFolderPeer({ peer, folderId: archive ? 1 : 0 })],
+            }));
+        }, `archiveChat ${chatId}`);
+    }
+    async pinDialog(chatId, pin) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            await this.client?.invoke(new Api.messages.ToggleDialogPin({
+                peer: new Api.InputDialogPeer({ peer }),
+                pinned: pin,
+            }));
+        }, `pinDialog ${chatId}`);
+    }
+    async markDialogUnread(chatId, unread) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            await this.client?.invoke(new Api.messages.MarkDialogUnread({
+                peer: new Api.InputDialogPeer({ peer }),
+                unread,
+            }));
+        }, `markDialogUnread ${chatId}`);
+    }
+    async getAdminLog(chatId, limit = 20, q) {
+        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("Admin log is only available for supergroups and channels");
+            }
+            const result = await this.client?.invoke(new Api.channels.GetAdminLog({
+                channel: entity,
+                q: q ?? "",
+                maxId: bigInt(0),
+                minId: bigInt(0),
+                limit,
+            }));
+            if (!result)
+                return [];
+            const userMap = new Map();
+            for (const u of result.users) {
+                if (u instanceof Api.User)
+                    userMap.set(u.id.toString(), u);
+            }
+            const describeUser = (userId) => {
+                const user = userMap.get(userId.toString());
+                if (!user)
+                    return userId.toString();
+                const parts = [user.firstName, user.lastName].filter(Boolean);
+                const name = parts.join(" ") || "Unknown";
+                return user.username ? `${name} (@${user.username})` : name;
+            };
+            return result.events.map((event) => ({
+                id: event.id.toString(),
+                date: new Date((event.date ?? 0) * 1000).toISOString(),
+                userId: event.userId.toString(),
+                userName: describeUser(event.userId),
+                action: describeAdminLogAction(event.action),
+                details: describeAdminLogDetails(event.action, describeUser),
+            }));
+        }, `getAdminLog for ${chatId}`);
+    }
+    async setChatPermissions(chatId, permissions) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        if (Object.values(permissions).every((v) => v === undefined))
+            return;
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            let currentRights;
+            if (entity instanceof Api.Channel) {
+                const full = await this.client?.invoke(new Api.channels.GetFullChannel({ channel: entity }));
+                const fullChannel = full?.chats?.find((c) => c instanceof Api.Channel && c.id.equals(entity.id));
+                currentRights = fullChannel?.defaultBannedRights ?? undefined;
+            }
+            else if (entity instanceof Api.Chat) {
+                const full = await this.client?.invoke(new Api.messages.GetFullChat({ chatId: entity.id }));
+                const fullChat = full?.chats?.find((c) => c instanceof Api.Chat && c.id.equals(entity.id));
+                currentRights = fullChat?.defaultBannedRights ?? undefined;
+            }
+            const peer = await this.client?.getInputEntity(entity);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            await this.client?.invoke(new Api.messages.EditChatDefaultBannedRights({
+                peer,
+                bannedRights: new Api.ChatBannedRights({ untilDate: 0, ...mergeBannedRights(currentRights, permissions) }),
+            }));
+        }, `setChatPermissions ${chatId}`);
+    }
+    async setSlowMode(chatId, seconds) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const allowed = [0, 10, 30, 60, 300, 900, 3600];
+        if (!allowed.includes(seconds)) {
+            throw new Error(`Invalid slow mode interval. Allowed values: ${allowed.join(", ")} (seconds)`);
+        }
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Slow mode is only available for supergroups");
+            }
+            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);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel) || !entity.forum) {
+                throw new Error("Forum topics are only available in forum supergroups");
+            }
+            const randomId = bigInt(Math.floor(Math.random() * 1e15));
+            const result = await this.client?.invoke(new Api.channels.CreateForumTopic({
+                channel: entity,
+                title,
+                iconColor,
+                iconEmojiId: iconEmojiId ? bigInt(iconEmojiId) : undefined,
+                randomId,
+            }));
+            let topicId = 0;
+            if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+                for (const update of result.updates) {
+                    if (update instanceof Api.UpdateNewChannelMessage &&
+                        update.message instanceof Api.MessageService &&
+                        update.message.action instanceof Api.MessageActionTopicCreate) {
+                        topicId = update.message.id;
+                        break;
+                    }
+                }
+                if (topicId === 0) {
+                    for (const update of result.updates) {
+                        if (update instanceof Api.UpdateMessageID && update.randomId?.equals(randomId)) {
+                            topicId = update.id;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (topicId === 0) {
+                throw new Error("Failed to determine created topic ID");
+            }
+            return { id: topicId, title };
+        }, `createForumTopic ${chatId}`);
+    }
+    async editForumTopic(chatId, topicId, 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) || !entity.forum) {
+                throw new Error("Forum topics are only available in forum supergroups");
+            }
+            await this.client?.invoke(new Api.channels.EditForumTopic({
+                channel: entity,
+                topicId,
+                title: options.title,
+                iconEmojiId: options.iconEmojiId ? bigInt(options.iconEmojiId) : undefined,
+                closed: options.closed,
+                hidden: options.hidden,
+            }));
+        }, `editForumTopic ${chatId}/${topicId}`);
+    }
+    async deleteForumTopic(chatId, topicId) {
+        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.forum) {
+                throw new Error("Forum topics are only available in forum supergroups");
+            }
+            await this.client?.invoke(new Api.channels.DeleteTopicHistory({
+                channel: entity,
+                topMsgId: topicId,
+            }));
+        }, `deleteForumTopic ${chatId}/${topicId}`);
+    }
     async exportInviteLink(chatId, options) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -1686,7 +3366,7 @@ export class TelegramService {
             .filter((inv) => inv instanceof Api.ChatInviteExported)
             .map((inv) => {
             const expiredByDate = inv.expireDate ? inv.expireDate < Math.floor(Date.now() / 1000) : false;
-            const expiredByUsage = inv.usageLimit !== undefined && inv.usage !== undefined ? inv.usage >= inv.usageLimit : false;
+            const expiredByUsage = inv.usageLimit != null && inv.usageLimit > 0 && inv.usage != null ? inv.usage >= inv.usageLimit : false;
             return {
                 link: inv.link,
                 title: inv.title,
@@ -1713,7 +3393,7 @@ export class TelegramService {
         const result = await this.client.invoke(new Api.messages.GetDialogFilters());
         const filters = "filters" in result ? result.filters : [];
         return filters
-            .filter((f) => f instanceof Api.DialogFilter)
+            .filter((f) => f instanceof Api.DialogFilter || f instanceof Api.DialogFilterChatlist)
             .map((f) => ({
             id: f.id,
             title: typeof f.title === "string" ? f.title : f.title.text,
@@ -1925,6 +3605,182 @@ export class TelegramService {
             });
         }, `sendSticker to ${chatId}`);
     }
+    async saveDraft(chatId, text, replyTo) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        await this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const peer = await this.client?.getInputEntity(resolved);
+            if (!peer)
+                throw new Error(`Cannot resolve peer for ${chatId}`);
+            const effectiveReplyTo = text === "" ? undefined : replyTo;
+            await this.client?.invoke(new Api.messages.SaveDraft({
+                peer,
+                message: text,
+                ...(effectiveReplyTo ? { replyTo: new Api.InputReplyToMessage({ replyToMsgId: effectiveReplyTo }) } : {}),
+            }));
+        }, `saveDraft in ${chatId}`);
+    }
+    async getAllDrafts() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetAllDrafts());
+            if (!result)
+                return [];
+            const updates = result instanceof Api.Updates || result instanceof Api.UpdatesCombined ? result.updates : [];
+            const users = result instanceof Api.Updates || result instanceof Api.UpdatesCombined ? result.users : [];
+            const chats = result instanceof Api.Updates || result instanceof Api.UpdatesCombined ? result.chats : [];
+            const userMap = new Map();
+            for (const u of users) {
+                if (u instanceof Api.User)
+                    userMap.set(u.id.toString(), u);
+            }
+            const chatMap = new Map();
+            for (const c of chats) {
+                if (c instanceof Api.Chat || c instanceof Api.Channel)
+                    chatMap.set(c.id.toString(), c);
+            }
+            const resolvePeerTitle = (peer) => {
+                if (peer instanceof Api.PeerUser) {
+                    const user = userMap.get(peer.userId.toString());
+                    if (user) {
+                        const parts = [user.firstName, user.lastName].filter(Boolean);
+                        const name = parts.join(" ") || "Unknown";
+                        return {
+                            id: peer.userId.toString(),
+                            title: user.username ? `${name} (@${user.username})` : name,
+                        };
+                    }
+                    return { id: peer.userId.toString(), title: peer.userId.toString() };
+                }
+                if (peer instanceof Api.PeerChat) {
+                    const chat = chatMap.get(peer.chatId.toString());
+                    return {
+                        id: peer.chatId.toString(),
+                        title: chat?.title ?? peer.chatId.toString(),
+                    };
+                }
+                if (peer instanceof Api.PeerChannel) {
+                    const channel = chatMap.get(peer.channelId.toString());
+                    return {
+                        id: peer.channelId.toString(),
+                        title: channel?.title ?? peer.channelId.toString(),
+                    };
+                }
+                return { id: "unknown", title: "unknown" };
+            };
+            const drafts = [];
+            for (const update of updates) {
+                if (update instanceof Api.UpdateDraftMessage && update.draft instanceof Api.DraftMessage) {
+                    const { id, title } = resolvePeerTitle(update.peer);
+                    drafts.push({
+                        chatId: id,
+                        chatTitle: title,
+                        text: update.draft.message ?? "",
+                        date: new Date((update.draft.date ?? 0) * 1000).toISOString(),
+                    });
+                }
+            }
+            return drafts;
+        }, "getAllDrafts");
+    }
+    async clearAllDrafts() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        await this.rateLimiter.execute(async () => {
+            await this.client?.invoke(new Api.messages.ClearAllDrafts());
+        }, "clearAllDrafts");
+    }
+    async getSavedDialogs(limit) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetSavedDialogs({
+                offsetDate: 0,
+                offsetId: 0,
+                offsetPeer: new Api.InputPeerEmpty(),
+                limit,
+                hash: bigInt(0),
+            }));
+            if (!result || result instanceof Api.messages.SavedDialogsNotModified)
+                return [];
+            const userMap = new Map();
+            for (const u of result.users) {
+                if (u instanceof Api.User)
+                    userMap.set(u.id.toString(), u);
+            }
+            const chatMap = new Map();
+            for (const c of result.chats) {
+                if (c instanceof Api.Chat || c instanceof Api.Channel)
+                    chatMap.set(c.id.toString(), c);
+            }
+            const resolvePeerTitle = (peer) => {
+                if (peer instanceof Api.PeerUser) {
+                    const user = userMap.get(peer.userId.toString());
+                    if (user) {
+                        const parts = [user.firstName, user.lastName].filter(Boolean);
+                        const name = parts.join(" ") || "Unknown";
+                        return {
+                            id: peer.userId.toString(),
+                            title: user.username ? `${name} (@${user.username})` : name,
+                        };
+                    }
+                    return { id: peer.userId.toString(), title: peer.userId.toString() };
+                }
+                if (peer instanceof Api.PeerChat) {
+                    const chat = chatMap.get(peer.chatId.toString());
+                    return { id: peer.chatId.toString(), title: chat?.title ?? peer.chatId.toString() };
+                }
+                if (peer instanceof Api.PeerChannel) {
+                    const channel = chatMap.get(peer.channelId.toString());
+                    return { id: peer.channelId.toString(), title: channel?.title ?? peer.channelId.toString() };
+                }
+                return { id: "unknown", title: "unknown" };
+            };
+            const dialogs = [];
+            for (const d of result.dialogs) {
+                if (d instanceof Api.SavedDialog) {
+                    const { id, title } = resolvePeerTitle(d.peer);
+                    dialogs.push({
+                        peerId: id,
+                        peerTitle: title,
+                        lastMsgId: d.topMessage,
+                    });
+                }
+            }
+            return dialogs;
+        }, "getSavedDialogs");
+    }
+    async getWebPreview(url) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetWebPagePreview({ message: url }));
+            if (!result)
+                return null;
+            const media = result.media;
+            if (!(media instanceof Api.MessageMediaWebPage))
+                return null;
+            const page = media.webpage;
+            if (page instanceof Api.WebPageEmpty) {
+                return { type: "empty", url: page.url };
+            }
+            if (page instanceof Api.WebPagePending) {
+                return { type: "pending", url: page.url };
+            }
+            if (page instanceof Api.WebPage) {
+                return {
+                    type: page.type ?? "article",
+                    url: page.url,
+                    title: page.title,
+                    description: page.description,
+                    siteName: page.siteName,
+                };
+            }
+            return null;
+        }, "getWebPreview");
+    }
     async getRecentStickers() {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -1944,4 +3800,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;
+    }
 }