zerogramjs 2.1.0

package/lib/Context.js

@@ -0,0 +1,195 @@
+const { Api } = require('telegram/tl');
+const { markdownToHtml, markdownToMarkdownV2 } = require('../utils/markdown');
+const Downloader = require('./Downloader');
+const debug = require('debug')('zerogram:context');
+
+class ContextFactory {
+    constructor(bot) {
+        this.bot = bot;
+        this.downloader = null;
+    }
+
+    create(update) {
+        const rawMessage = update.message ?? {};
+        // GramJS usa message.message para el texto, mapearlo a message.text para consistencia
+        const message = {
+            ...rawMessage,
+            text: rawMessage.message || rawMessage.text || ''
+        };
+        const peer = this._extractPeer(message, update);
+        const isCallback = update?.className === 'UpdateBotCallbackQuery' || update?.className === 'UpdateInlineBotCallbackQuery';
+        const callbackData = Buffer.isBuffer(update?.data)
+            ? update.data.toString('utf8')
+            : (update?.data ?? null);
+        const payload = callbackData ? callbackData.split(':')[0] : null;
+        const downloader = this._getDownloader();
+
+        return {
+            bot: this.bot,
+            client: this.bot.client,
+            update,
+            message,
+            isCallback,
+            callbackData,
+
+            reply: this._createReplyFn(peer, message.id),
+            send: this._createSendFn(peer),
+            sendFile: this._createSendFileFn(peer),
+            answerCallback: this._createAnswerCallbackFn(update),
+
+            getReplyMessage: this._createGetReplyMessageFn(peer, message),
+            getMessages: this._createGetMessagesFn(peer),
+            thumbFromVideo: (buf, opts) => this.bot.ffutil.thumbnail(buf, opts),
+
+            downloadMedia: (msg, opts) => downloader.downloadMedia(msg, opts),
+            downloadMediaStream: (msg, opts) => downloader.downloadMediaStream(msg, opts),
+            downloadMediaBatch: (msgs, opts) => downloader.downloadMediaBatch(msgs, opts),
+            downloadControllers: downloader.controllers
+        };
+    }
+
+    _getDownloader() {
+        if (!this.bot.client) {
+            throw new Error('Telegram client no está inicializado todavía');
+        }
+
+        if (!this.downloader || this.downloader.client !== this.bot.client) {
+            this.downloader = new Downloader(this.bot.client, this.bot.ffutil);
+        }
+
+        return this.downloader;
+    }
+
+    _extractPeer(message, update) {
+        // Para mensajes normales
+        const msgPeer = message.peerId ?? message.peer ?? null;
+        if (msgPeer) return msgPeer;
+
+        // Para callbacks: el peer está en update.peer (el chat) o update.userId (el usuario)
+        const callbackPeer = update?.peer ?? update?.chat ?? update?.chatInstance ?? null;
+        if (callbackPeer) return callbackPeer;
+
+        // Si no hay peer, intentar obtenerlo del bot
+        return update?.userId ?? update?.fromId ?? null;
+    }
+
+    _createAnswerCallbackFn(update) {
+        return async (text = '', opts = {}) => {
+            // GramJS usa snake_case en los updates
+            const queryId = update?.queryId ?? update?.query_id;
+
+            if (!queryId) {
+                throw new Error('answerCallback() solo está disponible en callbacks con queryId');
+            }
+
+            // Convertir a BigInt de forma segura
+            let queryIdBigInt;
+            try {
+                if (typeof queryId === 'bigint') {
+                    queryIdBigInt = queryId;
+                } else if (typeof queryId === 'string') {
+                    queryIdBigInt = BigInt(queryId);
+                } else if (typeof queryId === 'number') {
+                    queryIdBigInt = BigInt(queryId);
+                } else {
+                    // Puede ser un objeto con toString
+                    queryIdBigInt = BigInt(queryId.toString());
+                }
+            } catch (e) {
+                throw new Error(`Invalid queryId format: ${e.message}`);
+            }
+
+            return this.bot.client.invoke(new Api.messages.SetBotCallbackAnswer({
+                queryId: queryIdBigInt,
+                message: text || '',
+                alert: !!opts.alert,
+                url: opts.url,
+                cacheTime: Number.isInteger(opts.cacheTime) ? opts.cacheTime : 0
+            }));
+        };
+    }
+
+    _createReplyFn(peer, messageId) {
+        return (text, opts = {}) => {
+            const htmlText = markdownToHtml(text);
+
+            return (async () => {
+                let msg = await this.bot.client.sendMessage(peer, {
+                    message: htmlText,
+                    parseMode: 'html',
+                    replyTo: messageId,
+                    ...opts
+                });
+
+                if (Array.isArray(msg)) msg = msg[0];
+
+                msg.safeEdit = (newText, editOpts = {}) => {
+                    const htmlNewText = markdownToHtml(newText);
+                    return this.bot.client.editMessage(peer, {
+                        message: msg.id,
+                        text: htmlNewText,
+                        parseMode: 'html',
+                        ...editOpts
+                    }).catch((err) => {
+                        debug('safeEdit error:', err);
+                        return null;
+                    });
+                };
+
+                return msg;
+            })();
+        };
+    }
+
+    _createSendFn(peer) {
+        return (text, opts = {}) => {
+            const mode = opts.parseMode || 'html';
+            const formattedText = mode === 'markdownv2'
+                ? markdownToMarkdownV2(text)
+                : markdownToHtml(text);
+
+            return this.bot.client.sendMessage(peer, {
+                message: formattedText,
+                parseMode: mode,
+                ...opts
+            });
+        };
+    }
+
+    _createSendFileFn(peer) {
+        return (file, opts = {}) => {
+            return this.bot.client.sendFile(peer, { file, ...opts });
+        };
+    }
+
+    _createGetReplyMessageFn(peer, message) {
+        return async () => {
+            if (!message.replyTo) return null;
+
+            const id = message.replyTo.replyToMsgId ?? message.replyTo.msgId ?? null;
+            if (!id) return null;
+
+            try {
+                const [msg] = await this.bot.client.getMessages(peer, { ids: [id] });
+                return msg || null;
+            } catch (error) {
+                debug('Error getting reply message:', error);
+                return null;
+            }
+        };
+    }
+
+    _createGetMessagesFn(peer) {
+        return async (ids) => {
+            try {
+                if (!Array.isArray(ids)) ids = [ids];
+                return await this.bot.client.getMessages(peer, { ids });
+            } catch (error) {
+                debug('Error getting messages:', error);
+                throw error;
+            }
+        };
+    }
+}
+
+module.exports = ContextFactory;

package/lib/Downloader.js

@@ -0,0 +1,234 @@
+const path = require('path');
+const { PassThrough } = require('stream');
+const debug = require('debug')('zerogram:downloader');
+const { downloadControllers } = require('../shared/downloadState');
+
+/**
+ * Maneja descargas de medios con streaming real
+ */
+class Downloader {
+    constructor(client, ffutil) {
+        this.client = client;
+        this.ffutil = ffutil;
+        this.controllers = downloadControllers;
+    }
+
+    /**
+     * Descarga un medio con progreso
+     */
+    async downloadMedia(msg, opts = {}) {
+        const { filePath, onProgress, controller } = opts;
+
+        if (!msg) {
+            throw new Error('Message is required for downloadMedia');
+        }
+
+        if (controller?.signal?.aborted) {
+            throw new Error('DOWNLOAD_CANCELLED');
+        }
+
+        const startTime = Date.now();
+        let lastBytes = 0;
+
+        try {
+            const buffer = await this.client.downloadMedia(msg, {
+                outputFile: filePath,
+                progressCallback: (downloadedBytes, totalBytes) => {
+                    if (controller?.signal?.aborted) {
+                        throw new Error('DOWNLOAD_CANCELLED');
+                    }
+
+                    const elapsed = (Date.now() - startTime) / 1000;
+                    const speed = elapsed > 0 ? downloadedBytes / elapsed : 0;
+                    const delta = downloadedBytes - lastBytes;
+
+                    if (typeof onProgress === 'function') {
+                        onProgress({
+                            downloadedBytes,
+                            totalBytes,
+                            speed,
+                            percent: totalBytes ? (downloadedBytes / totalBytes) * 100 : 0,
+                            delta,
+                            elapsed
+                        });
+                    }
+
+                    lastBytes = downloadedBytes;
+                }
+            });
+
+            return buffer;
+        } catch (error) {
+            if (error.message === 'DOWNLOAD_CANCELLED') {
+                debug('Download cancelled by user');
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Descarga con streaming real - ¡NUEVO!
+     * Retorna un stream que empieza a emitir datos inmediatamente
+     */
+    downloadMediaStream(msg, opts = {}) {
+        const { onProgress, controller } = opts;
+
+        if (!msg) {
+            throw new Error('Message is required for downloadMediaStream');
+        }
+
+        const stream = new PassThrough();
+        const startTime = Date.now();
+        let downloadedBytes = 0;
+        let totalBytes = 0;
+
+        // Obtener el tamaño total del archivo
+        if (msg.media?.document) {
+            totalBytes = msg.media.document.size || 0;
+        } else if (msg.media?.photo) {
+            const sizes = msg.media.photo.sizes || [];
+            const largest = sizes[sizes.length - 1];
+            totalBytes = largest?.size || 0;
+        }
+
+        // Iniciar descarga asíncrona
+        (async () => {
+            try {
+                // Verificar cancelación inicial
+                if (controller?.signal?.aborted) {
+                    stream.destroy(new Error('DOWNLOAD_CANCELLED'));
+                    return;
+                }
+
+                // Usar iterDownload para streaming real
+                for await (const chunk of this.client.iterDownload({
+                    file: msg.media,
+                    requestSize: 512 * 1024, // 512KB chunks
+                })) {
+                    // Verificar cancelación en cada chunk
+                    if (controller?.signal?.aborted) {
+                        stream.destroy(new Error('DOWNLOAD_CANCELLED'));
+                        return;
+                    }
+
+                    downloadedBytes += chunk.length;
+
+                    // Escribir chunk al stream inmediatamente
+                    if (!stream.write(chunk)) {
+                        // Esperar si el buffer está lleno
+                        await new Promise(resolve => stream.once('drain', resolve));
+                    }
+
+                    // Callback de progreso
+                    if (typeof onProgress === 'function') {
+                        const elapsed = (Date.now() - startTime) / 1000;
+                        const speed = elapsed > 0 ? downloadedBytes / elapsed : 0;
+
+                        onProgress({
+                            downloadedBytes,
+                            totalBytes,
+                            speed,
+                            percent: totalBytes ? (downloadedBytes / totalBytes) * 100 : 0,
+                            elapsed
+                        });
+                    }
+                }
+
+                // Terminar el stream
+                stream.end();
+                debug('Stream completed successfully');
+
+            } catch (error) {
+                debug('Stream error:', error);
+                stream.destroy(error);
+            }
+        })();
+
+        return stream;
+    }
+
+    /**
+     * Descarga múltiples medios en lote
+     */
+    async downloadMediaBatch(messages, opts = {}) {
+        const { dir = '.', onProgress, controller } = opts;
+
+        if (!Array.isArray(messages) || messages.length === 0) {
+            throw new Error('messages[] is required and must not be empty');
+        }
+
+        if (controller?.signal?.aborted) {
+            throw new Error('DOWNLOAD_CANCELLED');
+        }
+
+        const totalBytes = messages.reduce((acc, msg) => {
+            return acc + (msg.media?.document?.size || 0);
+        }, 0);
+
+        let overallDownloaded = 0;
+        const results = [];
+
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+
+            if (controller?.signal?.aborted) {
+                throw new Error('DOWNLOAD_CANCELLED');
+            }
+
+            const fileName = this._extractFileName(msg, i);
+            const filePath = path.join(dir, fileName);
+
+            try {
+                const buffer = await this.downloadMedia(msg, {
+                    filePath,
+                    controller,
+                    onProgress: (progress) => {
+                        overallDownloaded += progress.delta;
+
+                        if (typeof onProgress === 'function') {
+                            onProgress({
+                                index: i + 1,
+                                total: messages.length,
+                                fileName,
+                                ...progress,
+                                overallDownloaded,
+                                overallTotal: totalBytes,
+                                overallPercent: totalBytes > 0
+                                    ? (overallDownloaded / totalBytes) * 100
+                                    : 0
+                            });
+                        }
+                    }
+                });
+
+                results.push({ filePath, buffer, message: msg });
+            } catch (error) {
+                if (error.message === 'DOWNLOAD_CANCELLED') {
+                    throw error;
+                }
+
+                debug(`Error downloading file ${i + 1}:`, error);
+                results.push({ filePath, error, message: msg });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Extrae el nombre de archivo de un mensaje
+     * @private
+     */
+    _extractFileName(msg, index) {
+        const attrs = msg.media?.document?.attributes;
+        if (attrs) {
+            const fileAttr = attrs.find(a => a.fileName);
+            if (fileAttr?.fileName) {
+                return fileAttr.fileName;
+            }
+        }
+        return `file_${msg.id || index}`;
+    }
+}
+
+module.exports = Downloader;

package/lib/Router.js

@@ -0,0 +1,152 @@
+const debug = require('debug')('zerogram:router');
+
+/**
+ * Maneja el enrutamiento de comandos y callbacks
+ */
+class Router {
+    constructor() {
+        this.commands = new Map();
+        this.callbacks = new Map();
+        this.middlewares = [];
+    }
+
+    /**
+     * Registra un comando
+     */
+    addCommand(name, handler) {
+        this.commands.set(name, handler);
+    }
+
+    /**
+     * Registra un callback
+     */
+    addCallback(action, handler) {
+        this.callbacks.set(action, handler);
+    }
+
+    /**
+     * Registra un middleware
+     */
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
+    }
+
+    /**
+     * Procesa una actualización
+     */
+    async route(ctx, update) {
+        // Ejecutar middlewares
+        await this._runMiddlewares(ctx);
+
+        // Detectar tipo de update
+        if (this._isCommand(ctx)) {
+            return this._handleCommand(ctx);
+        }
+
+        if (this._isCallback(update)) {
+            return this._handleCallback(ctx, update);
+        }
+
+        // Evento no manejado
+        ctx.bot.emit('unhandled', ctx);
+    }
+
+    /**
+     * Verifica si es un comando
+     * @private
+     */
+    _isCommand(ctx) {
+        const text = ctx.message.text || ctx.message.message || '';
+        return text.startsWith('/');
+    }
+
+    /**
+     * Verifica si es un callback
+     * @private
+     */
+    _isCallback(update) {
+        const name = update?.className;
+        return name === 'UpdateBotCallbackQuery' || name === 'UpdateInlineBotCallbackQuery';
+    }
+
+    /**
+     * Maneja comandos
+     * @private
+     */
+    async _handleCommand(ctx) {
+        const text = ctx.message.text || ctx.message.message || '';
+        const [cmd, ...args] = text.slice(1).split(/\s+/);
+
+        const handler = this.commands.get(cmd);
+        if (handler) {
+            debug(`Executing command: /${cmd}`);
+            return handler(ctx, args);
+        }
+    }
+
+    /**
+     * Maneja callbacks
+     * @private
+     */
+    async _handleCallback(ctx, update) {
+        const data = update.data.toString('utf8');
+        let action, payload;
+
+        if (data.includes(':')) {
+            // Formato action:payload (con dos puntos)
+            const [actionPart, ...payloadParts] = data.split(':');
+            action = actionPart;
+            payload = payloadParts.join(':');
+        } else if (/_\d+$/.test(data)) {
+            // Formato action_payload (con underscore y número al final)
+            const lastUnderscore = data.lastIndexOf('_');
+            action = data.substring(0, lastUnderscore + 1); // incluye el _
+            payload = data.substring(lastUnderscore + 1);
+        } else {
+            // Formato simple sin separador
+            action = data;
+            payload = '';
+        }
+
+        debug(`Callback received - data: ${data}, action: ${action}, payload: ${payload}`);
+
+        const handler = this.callbacks.get(action);
+        if (handler) {
+            debug(`Executing callback handler: ${action}`);
+            return handler({
+                ...ctx,
+                action,
+                payload,
+                queryId: update.queryId,
+                userId: update.userId?.toString()
+            });
+        } else {
+            debug(`No handler found for callback: ${action}`);
+        }
+    }
+
+    /**
+     * Ejecuta middlewares en cadena
+     * @private
+     */
+    async _runMiddlewares(ctx) {
+        let index = -1;
+
+        const dispatch = async (i) => {
+            if (i <= index) {
+                throw new Error('next() called multiple times');
+            }
+
+            index = i;
+            const middleware = this.middlewares[i];
+
+            if (!middleware) return;
+
+            await middleware(ctx, () => dispatch(i + 1));
+        };
+
+        await dispatch(0);
+    }
+}
+
+module.exports = Router;

package/lib/Session.js

@@ -0,0 +1,77 @@
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const debug = require('debug')('zerogram:session');
+
+/**
+ * Maneja la persistencia de sesiones
+ */
+class SessionManager {
+    constructor(botToken, sessionsDir) {
+        this.sessionsDir = path.resolve(sessionsDir);
+        this.sessionFile = path.join(
+            this.sessionsDir,
+            `${botToken.split(':')[0]}.session`
+        );
+    }
+
+    /**
+     * Carga una sesión existente
+     * @returns {Promise<string>} Session data o string vacío
+     */
+    async load() {
+        try {
+            // Crear directorio si no existe
+            if (!fsSync.existsSync(this.sessionsDir)) {
+                await fs.mkdir(this.sessionsDir, { recursive: true });
+                debug('Sessions directory created');
+            }
+
+            // Cargar archivo de sesión
+            if (fsSync.existsSync(this.sessionFile)) {
+                const data = await fs.readFile(this.sessionFile, 'utf8');
+                debug('Session loaded from file');
+                return data;
+            }
+
+            debug('No existing session found');
+            return '';
+        } catch (error) {
+            debug('Error loading session:', error);
+            return '';
+        }
+    }
+
+    /**
+     * Guarda la sesión actual
+     * @param {string} sessionData - Datos de sesión a guardar
+     * @returns {Promise<void>}
+     */
+    async save(sessionData) {
+        try {
+            await fs.writeFile(this.sessionFile, sessionData, 'utf8');
+            debug('Session saved successfully');
+        } catch (error) {
+            debug('Error saving session:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Elimina la sesión
+     * @returns {Promise<void>}
+     */
+    async delete() {
+        try {
+            if (fsSync.existsSync(this.sessionFile)) {
+                await fs.unlink(this.sessionFile);
+                debug('Session deleted');
+            }
+        } catch (error) {
+            debug('Error deleting session:', error);
+            throw error;
+        }
+    }
+}
+
+module.exports = SessionManager;