clawgram 2.0.0

package/dist/gramjs-client.js

@@ -0,0 +1,437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GramJsClientManager = void 0;
+const telegram_1 = require("telegram");
+const sessions_1 = require("telegram/sessions");
+const proxy_config_1 = require("./proxy-config");
+const history_1 = require("./history");
+function toStringId(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    try {
+        return String(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function inferChatTypeFromRaw(raw) {
+    if (raw.startsWith("-100"))
+        return "channel";
+    if (raw.startsWith("-"))
+        return "group";
+    return "direct";
+}
+function getChatIdFromPeer(peer, fallback) {
+    const userId = toStringId(peer?.userId);
+    if (userId)
+        return userId;
+    const chatId = toStringId(peer?.chatId);
+    if (chatId)
+        return `-${chatId.replace(/^-/, "")}`;
+    const channelId = toStringId(peer?.channelId);
+    if (channelId)
+        return `-100${channelId.replace(/^-100|-/, "")}`;
+    return fallback;
+}
+function toSafeInteger(value) {
+    if (!/^-?\d+$/.test(value)) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+function uniqueCandidates(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const key = typeof value === "object" ? String(value) : `${typeof value}:${String(value)}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(value);
+    }
+    return result;
+}
+function parseTargetWithThread(rawTarget) {
+    const raw = rawTarget.trim();
+    const topicMatch = /^(.+?):topic:(\d+)$/.exec(raw);
+    if (topicMatch) {
+        return {
+            raw,
+            chatId: topicMatch[1],
+            messageThreadId: Number.parseInt(topicMatch[2], 10),
+        };
+    }
+    const colonMatch = /^(.+):(\d+)$/.exec(raw);
+    if (colonMatch && /^-?\d+$/.test(colonMatch[1])) {
+        return {
+            raw,
+            chatId: colonMatch[1],
+            messageThreadId: Number.parseInt(colonMatch[2], 10),
+        };
+    }
+    return {
+        raw,
+        chatId: raw,
+    };
+}
+function buildForumReplyParams(messageThreadId, replyToMessageId) {
+    const normalizedThreadId = typeof messageThreadId === "number" && Number.isFinite(messageThreadId)
+        ? Math.trunc(messageThreadId)
+        : undefined;
+    const normalizedReplyToId = typeof replyToMessageId === "number" && Number.isFinite(replyToMessageId)
+        ? Math.trunc(replyToMessageId)
+        : undefined;
+    if (!normalizedThreadId || normalizedThreadId <= 1) {
+        return normalizedReplyToId ? { replyTo: normalizedReplyToId } : {};
+    }
+    if (!normalizedReplyToId) {
+        return {
+            replyTo: normalizedThreadId,
+        };
+    }
+    if (normalizedReplyToId === normalizedThreadId) {
+        return {
+            replyTo: normalizedReplyToId,
+        };
+    }
+    return {
+        replyTo: normalizedReplyToId,
+        topMsgId: normalizedThreadId,
+    };
+}
+function buildPeerCandidates(raw, kind) {
+    const candidates = [raw];
+    const numeric = toSafeInteger(raw);
+    if (numeric !== undefined) {
+        candidates.push(numeric);
+    }
+    if ((kind === "group" || kind === "channel") && /^\d+$/.test(raw)) {
+        const supergroupId = `-100${raw}`;
+        const basicGroupId = `-${raw}`;
+        candidates.push(supergroupId, toSafeInteger(supergroupId), basicGroupId, toSafeInteger(basicGroupId));
+    }
+    return uniqueCandidates(candidates.filter((value) => value !== undefined));
+}
+function collectDialogKeys(dialog) {
+    const keys = new Set();
+    const add = (value) => {
+        const id = toStringId(value);
+        if (id) {
+            keys.add(id);
+        }
+    };
+    add(dialog?.id);
+    add(dialog?.inputEntity);
+    add(dialog?.entity?.id);
+    add(getChatIdFromPeer(dialog?.inputEntity));
+    add(getChatIdFromPeer(dialog?.entity));
+    const inputChatId = toStringId(dialog?.inputEntity?.chatId);
+    if (inputChatId) {
+        keys.add(inputChatId);
+        keys.add(`-${inputChatId.replace(/^-/, "")}`);
+    }
+    const inputChannelId = toStringId(dialog?.inputEntity?.channelId);
+    if (inputChannelId) {
+        keys.add(inputChannelId);
+        keys.add(`-100${inputChannelId.replace(/^-100|-/, "")}`);
+    }
+    return keys;
+}
+function buildTargetKeys(raw, kind) {
+    const keys = new Set();
+    const add = (value) => {
+        const id = toStringId(value);
+        if (id) {
+            keys.add(id);
+        }
+    };
+    add(raw);
+    if ((kind === "group" || kind === "channel") && /^\d+$/.test(raw)) {
+        add(`-100${raw}`);
+        add(`-${raw}`);
+    }
+    if (raw.startsWith("-100")) {
+        add(raw.replace(/^-100/, ""));
+    }
+    else if (raw.startsWith("-")) {
+        add(raw.replace(/^-/, ""));
+    }
+    return keys;
+}
+class GramJsClientManager {
+    config;
+    client;
+    proxy;
+    started = false;
+    constructor(config) {
+        this.config = config;
+        const clientOptions = (0, proxy_config_1.buildTelegramClientOptions)(config.proxy);
+        this.proxy = clientOptions.proxy;
+        this.client = new telegram_1.TelegramClient(new sessions_1.StringSession(config.sessionString), config.apiId, config.apiHash, clientOptions);
+    }
+    /** Credential-free proxy summary (`socks4`/`socks5`) for diagnostics. */
+    getProxySummary() {
+        return (0, proxy_config_1.describeProxy)(this.proxy);
+    }
+    async start() {
+        if (this.started)
+            return;
+        await this.client.connect();
+        const authorized = await this.client.checkAuthorization();
+        if (!authorized) {
+            throw new Error("GramJS client connected, but session is not authorized.");
+        }
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        await this.client.disconnect();
+        this.started = false;
+    }
+    getClient() {
+        return this.client;
+    }
+    async getMe() {
+        return this.client.getMe();
+    }
+    async resolveDialogPeer(raw, kind) {
+        const targetKeys = buildTargetKeys(raw, kind);
+        const dialogs = await this.client.getDialogs({ limit: 200 }).catch(() => []);
+        for (const dialog of dialogs) {
+            if (kind === "user" && !dialog?.isUser) {
+                continue;
+            }
+            if ((kind === "group" || kind === "channel") && !dialog?.isGroup && !dialog?.isChannel) {
+                continue;
+            }
+            const dialogKeys = collectDialogKeys(dialog);
+            const matched = [...targetKeys].some((key) => dialogKeys.has(key));
+            if (!matched) {
+                continue;
+            }
+            const chatId = getChatIdFromPeer(dialog?.inputEntity) ?? toStringId(dialog?.id) ?? raw;
+            const chatType = kind === "group"
+                ? "group"
+                : kind === "channel"
+                    ? "channel"
+                    : dialog?.isGroup
+                        ? "group"
+                        : dialog?.isChannel
+                            ? "channel"
+                            : "direct";
+            return {
+                raw,
+                peer: dialog.inputEntity,
+                chatId,
+                chatType,
+            };
+        }
+        return undefined;
+    }
+    async resolvePeer(rawTarget, options) {
+        if (typeof rawTarget !== "string") {
+            const entity = await this.client.getInputEntity(rawTarget).catch(() => rawTarget);
+            return {
+                raw: String(rawTarget ?? ""),
+                peer: entity
+            };
+        }
+        const parsedTarget = parseTargetWithThread(rawTarget);
+        const raw = parsedTarget.raw;
+        const chatLookupTarget = parsedTarget.chatId;
+        const kind = options?.kind;
+        if (raw === "me" || raw === "self" || raw === "saved") {
+            return {
+                raw,
+                peer: "me",
+                chatId: "me",
+                messageThreadId: parsedTarget.messageThreadId,
+                chatType: "direct"
+            };
+        }
+        let entity;
+        for (const candidate of buildPeerCandidates(chatLookupTarget, kind)) {
+            entity = await this.client.getInputEntity(candidate).catch(() => undefined);
+            if (entity) {
+                break;
+            }
+        }
+        if (!entity) {
+            const dialogResolved = await this.resolveDialogPeer(chatLookupTarget, kind);
+            if (dialogResolved) {
+                dialogResolved.messageThreadId = parsedTarget.messageThreadId;
+                return dialogResolved;
+            }
+        }
+        if (!entity) {
+            entity = await this.client.getInputEntity(chatLookupTarget);
+        }
+        const chatId = getChatIdFromPeer(entity, chatLookupTarget);
+        return {
+            raw,
+            peer: entity,
+            chatId,
+            messageThreadId: parsedTarget.messageThreadId,
+            chatType: inferChatTypeFromRaw(chatId ?? raw)
+        };
+    }
+    async sendText(args) {
+        const resolved = await this.resolvePeer(args.target, { kind: args.targetKind });
+        const messageThreadId = args.messageThreadId ?? resolved.messageThreadId;
+        const replyParams = buildForumReplyParams(messageThreadId, args.replyToMessageId);
+        return this.client.sendMessage(resolved.peer, {
+            message: args.text,
+            ...replyParams,
+        });
+    }
+    /**
+     * Reads a window of chat history.
+     *
+     * Telegram returns newest first and `offsetDate` means "older than this", so
+     * an upper bound is expressed by starting there. The lower bound has no
+     * server-side equivalent in this call, so it is applied after the fact — which
+     * is also why `limit` is the real guard: a window spanning a quiet week and a
+     * window spanning a busy hour cost the same request but not the same context.
+     */
+    async listMessages(args) {
+        const resolved = await this.resolvePeer(args.target);
+        const query = (0, history_1.buildHistoryQuery)(args);
+        const fetched = await this.client.getMessages(resolved.peer, query);
+        const raw = Array.isArray(fetched) ? fetched : [];
+        return {
+            chatId: resolved.chatId,
+            messages: (0, history_1.collectHistoryWindow)(raw, {
+                since: args.since,
+                until: args.until,
+                fallbackChatId: resolved.chatId,
+            }),
+            truncated: raw.length >= args.limit,
+        };
+    }
+    /**
+     * Chat membership, ids only. The caller needs to answer "do we share a group
+     * with this person" — an id answers that and a full profile does not, so
+     * names and phone numbers are deliberately left out.
+     */
+    async listParticipants(args) {
+        const resolved = await this.resolvePeer(args.target);
+        const fetched = await this.client.getParticipants(resolved.peer, {
+            limit: args.limit,
+        });
+        const raw = Array.isArray(fetched) ? fetched : [];
+        const participants = [];
+        for (const entry of raw) {
+            const rawId = entry?.id;
+            if (rawId === undefined || rawId === null) {
+                continue;
+            }
+            const username = typeof entry?.username === "string" && entry.username.length > 0
+                ? entry.username
+                : undefined;
+            const member = {
+                userId: String(rawId),
+                username,
+                isBot: entry?.bot === true,
+            };
+            // Display names are personal data, so they are opt-in: only the identity
+            // linking flow asks for them, and it discards them once a link is made.
+            if (args.includeNames) {
+                if (typeof entry?.firstName === "string" && entry.firstName.length > 0)
+                    member.firstName = entry.firstName;
+                if (typeof entry?.lastName === "string" && entry.lastName.length > 0)
+                    member.lastName = entry.lastName;
+            }
+            participants.push(member);
+        }
+        return {
+            chatId: resolved.chatId,
+            participants,
+            truncated: raw.length >= args.limit,
+        };
+    }
+    async markRead(target, messageId, options) {
+        if (!messageId || !Number.isFinite(messageId)) {
+            return;
+        }
+        const resolved = await this.resolvePeer(target);
+        const messageThreadId = options?.messageThreadId ?? resolved.messageThreadId;
+        if (messageThreadId && messageThreadId > 1) {
+            await this.client.invoke(new telegram_1.Api.messages.ReadDiscussion({
+                peer: resolved.peer,
+                msgId: messageThreadId,
+                readMaxId: messageId,
+            })).catch(() => undefined);
+            return;
+        }
+        await this.client.markAsRead(resolved.peer, messageId).catch(() => undefined);
+    }
+    async withTyping(target, fn, options) {
+        let peer;
+        let readMarked = false;
+        let stopped = false;
+        let activeTick;
+        const sendTyping = async () => {
+            if (!peer) {
+                peer = (await this.resolvePeer(target)).peer;
+            }
+            if (stopped) {
+                return;
+            }
+            if (!readMarked) {
+                readMarked = true;
+                await this.markRead(peer, options?.readMessageId, {
+                    messageThreadId: options?.messageThreadId,
+                }).catch(() => undefined);
+            }
+            if (stopped) {
+                return;
+            }
+            await this.client.invoke(new telegram_1.Api.messages.SetTyping({
+                peer: peer,
+                topMsgId: options?.messageThreadId,
+                action: new telegram_1.Api.SendMessageTypingAction(),
+            }));
+        };
+        const tick = () => {
+            if (stopped || activeTick) {
+                return;
+            }
+            activeTick = sendTyping()
+                .catch(() => undefined)
+                .finally(() => {
+                activeTick = undefined;
+            });
+        };
+        tick();
+        const interval = setInterval(tick, 4000);
+        try {
+            return await fn();
+        }
+        finally {
+            stopped = true;
+            clearInterval(interval);
+            await activeTick?.catch(() => undefined);
+            if (peer) {
+                await this.client.invoke(new telegram_1.Api.messages.SetTyping({
+                    peer: peer,
+                    action: new telegram_1.Api.SendMessageCancelAction(),
+                })).catch(() => undefined);
+            }
+        }
+    }
+    async sendMedia(args) {
+        const resolved = await this.resolvePeer(args.target);
+        const messageThreadId = args.messageThreadId ?? resolved.messageThreadId;
+        const replyParams = buildForumReplyParams(messageThreadId, args.replyToMessageId);
+        return this.client.sendFile(resolved.peer, {
+            file: args.file,
+            caption: args.caption,
+            ...replyParams,
+        });
+    }
+}
+exports.GramJsClientManager = GramJsClientManager;

package/dist/group-reply-address.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rememberGroupReplyAddress = rememberGroupReplyAddress;
+exports.consumeGroupReplyAddress = consumeGroupReplyAddress;
+exports.buildGroupReplyAddress = buildGroupReplyAddress;
+const helpers_1 = require("./helpers");
+const groupReplyAddresses = new Map();
+const GROUP_REPLY_ADDRESS_TTL_MS = 10 * 60 * 1000;
+const GROUP_REPLY_LATEST_ID = "__latest__";
+function normalizeGroupReplyTarget(rawTarget) {
+    if (typeof rawTarget !== "string") {
+        return String(rawTarget ?? "").trim();
+    }
+    return (0, helpers_1.normalizeOutboundTarget)(rawTarget) || rawTarget.trim();
+}
+function buildGroupReplyAddressKey(input) {
+    const chatId = normalizeGroupReplyTarget(input.chatId);
+    const replyToId = input.replyToId === null || input.replyToId === undefined ? "" : String(input.replyToId).trim();
+    if (!chatId || !replyToId) {
+        return undefined;
+    }
+    return [input.accountId ?? "", chatId, replyToId].join("\n");
+}
+function rememberGroupReplyAddress(input) {
+    if (!input.address) {
+        return;
+    }
+    const key = buildGroupReplyAddressKey(input);
+    if (!key) {
+        return;
+    }
+    groupReplyAddresses.set(key, {
+        address: input.address,
+        expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
+    });
+    const latestKey = buildGroupReplyAddressKey({
+        ...input,
+        replyToId: GROUP_REPLY_LATEST_ID,
+    });
+    if (latestKey) {
+        groupReplyAddresses.set(latestKey, {
+            address: input.address,
+            expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
+        });
+    }
+}
+function consumeGroupReplyAddress(input) {
+    const latestKey = buildGroupReplyAddressKey({
+        ...input,
+        replyToId: GROUP_REPLY_LATEST_ID,
+    });
+    const key = buildGroupReplyAddressKey(input) ?? latestKey;
+    if (!key) {
+        return undefined;
+    }
+    const stored = groupReplyAddresses.get(key);
+    if (!stored) {
+        return undefined;
+    }
+    groupReplyAddresses.delete(key);
+    if (latestKey) {
+        groupReplyAddresses.delete(latestKey);
+    }
+    if (stored.expiresAt < Date.now()) {
+        return undefined;
+    }
+    return stored.address;
+}
+function buildGroupReplyAddress(input) {
+    const username = input.senderUsername?.replace(/^@/, "").trim();
+    if (username) {
+        return `@${username}`;
+    }
+    const display = input.senderDisplay?.trim();
+    if (display && display !== "Telegram") {
+        return display;
+    }
+    return input.senderId;
+}

package/dist/group-visible-reply-guard.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRecentVisibleGroupReply = hasRecentVisibleGroupReply;
+exports.rememberVisibleGroupReply = rememberVisibleGroupReply;
+const helpers_1 = require("./helpers");
+const recentVisibleGroupReplies = new Map();
+const GROUP_VISIBLE_REPLY_TTL_MS = 10 * 60 * 1000;
+function buildVisibleGroupReplyKey(input) {
+    const chatId = (0, helpers_1.normalizeOutboundTarget)(String(input.chatId ?? "").trim());
+    const currentMessageId = input.currentMessageId === null || input.currentMessageId === undefined
+        ? ""
+        : String(input.currentMessageId).trim();
+    if (!chatId || !currentMessageId) {
+        return undefined;
+    }
+    return [input.accountId ?? "", chatId, currentMessageId].join("\n");
+}
+function pruneExpiredEntries(now) {
+    for (const [key, expiresAt] of recentVisibleGroupReplies.entries()) {
+        if (expiresAt <= now) {
+            recentVisibleGroupReplies.delete(key);
+        }
+    }
+}
+function hasRecentVisibleGroupReply(input) {
+    const now = Date.now();
+    pruneExpiredEntries(now);
+    const key = buildVisibleGroupReplyKey(input);
+    if (!key) {
+        return false;
+    }
+    const expiresAt = recentVisibleGroupReplies.get(key);
+    if (!expiresAt) {
+        return false;
+    }
+    if (expiresAt <= now) {
+        recentVisibleGroupReplies.delete(key);
+        return false;
+    }
+    return true;
+}
+function rememberVisibleGroupReply(input) {
+    const key = buildVisibleGroupReplyKey(input);
+    if (!key) {
+        return;
+    }
+    recentVisibleGroupReplies.set(key, Date.now() + GROUP_VISIBLE_REPLY_TTL_MS);
+}