zerogramjs 2.1.0

package/lib/Zerogram.js

@@ -0,0 +1,325 @@
+const { EventEmitter } = require('events');
+const { TelegramClient } = require('telegram');
+const { StringSession } = require('telegram/sessions');
+const { Button } = require('telegram/tl/custom/button');
+const debug = require('debug')('zerogram');
+
+const SessionManager = require('./Session');
+const Router = require('./Router');
+const ContextFactory = require('./Context');
+const { FFMpegUtil } = require('../utils/ffmpeg');
+
+/**
+ * Clase principal de Zerogram
+ * @extends EventEmitter
+ */
+class Zerogram extends EventEmitter {
+    /**
+     * @param {number} apiId - Telegram API ID
+     * @param {string} apiHash - Telegram API Hash
+     * @param {string} botToken - Bot token from @BotFather
+     * @param {Object} opts - Opciones adicionales
+     * @param {boolean} opts.debug - Activar modo debug
+     * @param {string} opts.sessionsDir - Directorio para sesiones
+     * @param {number} opts.maxRetries - Máximo de reintentos de conexión
+     * @param {number} opts.retryDelay - Delay entre reintentos (ms)
+     */
+    constructor(apiId, apiHash, botToken, opts = {}) {
+        super();
+
+        this._validateConfig(apiId, apiHash, botToken);
+
+        this.apiId = apiId;
+        this.apiHash = apiHash;
+        this.botToken = botToken;
+
+        // Opciones
+        this.options = {
+            debug: !!opts.debug,
+            sessionsDir: opts.sessionsDir || 'sessions',
+            maxRetries: opts.maxRetries || 3,
+            retryDelay: opts.retryDelay || 2000,
+            connectionRetries: opts.connectionRetries || 3,
+            useWSS: opts.useWSS !== false,
+            maxConcurrentDownloads: opts.maxConcurrentDownloads || 1
+        };
+
+        // Componentes internos
+        this.sessionManager = new SessionManager(this.botToken, this.options.sessionsDir);
+        this.router = new Router();
+        this.contextFactory = new ContextFactory(this);
+        this.ffutil = FFMpegUtil.create();
+
+        // Estado
+        this.client = null;
+        this._initialized = false;
+
+        // Manejo de señales del sistema
+        this._setupSignalHandlers();
+    }
+
+    /**
+     * Valida la configuración inicial
+     * @private
+     */
+    _validateConfig(apiId, apiHash, botToken) {
+        if (!apiId || typeof apiId !== 'number') {
+            throw new Error('apiId must be a valid number');
+        }
+        if (!apiHash || typeof apiHash !== 'string') {
+            throw new Error('apiHash must be a valid string');
+        }
+        if (!botToken || typeof botToken !== 'string' || !botToken.includes(':')) {
+            throw new Error('botToken must be a valid bot token');
+        }
+    }
+
+    /**
+     * Configura manejadores de señales del sistema
+     * @private
+     */
+    _setupSignalHandlers() {
+        const shutdown = async (signal) => {
+            debug(`Received ${signal}, shutting down gracefully...`);
+            await this.stop();
+            process.exit(0);
+        };
+
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+    }
+
+    /**
+     * Inicializa el cliente de Telegram
+     * @returns {Promise<void>}
+     */
+    async init() {
+        if (this._initialized) {
+            debug('Client already initialized');
+            return;
+        }
+
+        try {
+            // Cargar sesión existente
+            const sessionData = await this.sessionManager.load();
+
+            // Crear cliente
+            this.client = new TelegramClient(
+                new StringSession(sessionData),
+                this.apiId,
+                this.apiHash,
+                {
+                    connectionRetries: this.options.connectionRetries,
+                    useWSS: this.options.useWSS,
+                    retryDelay: this.options.retryDelay,
+                    maxConcurrentDownloads: this.options.maxConcurrentDownloads
+                }
+            );
+
+            // Conectar con reintentos
+            await this._connectWithRetry();
+
+            // Guardar sesión
+            await this.sessionManager.save(this.client.session.save());
+
+            // Configurar router
+            this.client.addEventHandler((update) =>
+                this._handleUpdate(update).catch((err) => {
+                    debug('Error handling update:', err);
+                    this.emit('error', err);
+                })
+            );
+
+            this._initialized = true;
+            this.emit('ready');
+            debug('Client initialized successfully');
+        } catch (error) {
+            debug('Initialization failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Conecta al cliente con manejo de reintentos y FloodWait
+     * @private
+     */
+    async _connectWithRetry() {
+        const { maxRetries, retryDelay } = this.options;
+
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                debug(`Connection attempt ${attempt}/${maxRetries}`);
+                await this.client.start({ botAuthToken: this.botToken });
+                debug('Connection successful');
+                return;
+            } catch (error) {
+                debug(`Connection attempt ${attempt} failed:`, error.message);
+
+                // Manejo de FloodWait
+                if (error.errorMessage === 'FLOOD') {
+                    const waitTime = error.seconds || 300;
+                    console.warn(`⏰ FloodWait: waiting ${waitTime}s before retry...`);
+
+                    if (attempt < maxRetries) {
+                        await this._sleep(waitTime * 1000);
+                        continue;
+                    } else {
+                        throw new Error(`FloodWait: Must wait ${waitTime}s. Try again later.`);
+                    }
+                }
+
+                // Último intento fallido
+                if (attempt === maxRetries) {
+                    throw error;
+                }
+
+                // Esperar antes del siguiente intento
+                await this._sleep(retryDelay * attempt);
+            }
+        }
+    }
+
+    /**
+     * Maneja actualizaciones de Telegram
+     * @private
+     */
+    async _handleUpdate(update) {
+        // Ignorar mensajes salientes
+        if (update?.message?.out) return;
+
+        const ctx = this.contextFactory.create(update);
+        await this.router.route(ctx, update);
+    }
+
+    /**
+     * Detiene el cliente
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        if (!this.client || !this._initialized) {
+            debug('Client not initialized or already stopped');
+            return;
+        }
+
+        try {
+            await this.sessionManager.save(this.client.session.save());
+            await this.client.disconnect();
+            this._initialized = false;
+            this.emit('stopped');
+            debug('Client stopped successfully');
+        } catch (error) {
+            debug('Error during stop:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Registra un comando
+     * @param {string} name - Nombre del comando (sin /)
+     * @param {Function} handler - Función manejadora (ctx, args) => {}
+     */
+    command(name, handler) {
+        if (typeof name !== 'string' || !name) {
+            throw new Error('Command name must be a non-empty string');
+        }
+        if (typeof handler !== 'function') {
+            throw new Error('Command handler must be a function');
+        }
+        this.router.addCommand(name, handler);
+        debug(`Command registered: ${name}`);
+    }
+
+    /**
+     * Registra un callback handler
+     * @param {string} action - Nombre de la acción
+     * @param {Function} handler - Función manejadora
+     */
+    onCallback(action, handler) {
+        if (typeof action !== 'string' || !action) {
+            throw new Error('Callback action must be a non-empty string');
+        }
+        if (typeof handler !== 'function') {
+            throw new Error('Callback handler must be a function');
+        }
+        this.router.addCallback(action, handler);
+        debug(`Callback registered: ${action}`);
+    }
+
+    /**
+     * Registra un middleware
+     * @param {Function} middleware - Función middleware (ctx, next) => {}
+     */
+    use(middleware) {
+        if (typeof middleware !== 'function') {
+            throw new Error('Middleware must be a function');
+        }
+        this.router.addMiddleware(middleware);
+        debug('Middleware registered');
+    }
+
+    /**
+     * Helper para crear botones inline
+     * @static
+     */
+    static createButton(text, callbackData) {
+        const dataBuf = Buffer.isBuffer(callbackData)
+            ? callbackData
+            : Buffer.from(String(callbackData));
+        return Button.inline(text, dataBuf);
+    }
+
+    /**
+     * Helper para crear botones URL
+     * @static
+     */
+    static urlButton(text, url) {
+        return Button.url(text, url);
+    }
+
+    /**
+     * Obtiene el historial de mensajes de un chat
+     * @param {string|number} chatId - ID del chat
+     * @param {Object} options - Opciones
+     * @param {number} options.limit - Número máximo de mensajes (default: 100)
+     * @param {number} options.offset - Offset para paginación
+     * @param {Date} options.fromDate - Fecha desde la cual obtener mensajes
+     * @param {Date} options.toDate - Fecha hasta la cual obtener mensajes
+     * @returns {Promise<Array>} Array de mensajes
+     */
+    async getHistory(chatId, options = {}) {
+        if (!this.client || !this._initialized) {
+            throw new Error('Client not initialized');
+        }
+
+        const {
+            limit = 100,
+            offset = 0,
+            fromDate,
+            toDate
+        } = options;
+
+        try {
+            const messages = await this.client.getMessages(chatId, {
+                limit,
+                offsetId: offset,
+                minId: fromDate ? Math.floor(fromDate.getTime() / 1000) : undefined,
+                maxId: toDate ? Math.floor(toDate.getTime() / 1000) : undefined
+            });
+
+            return messages;
+        } catch (error) {
+            debug('Error getting history:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Utilidad para sleep
+     * @private
+     */
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = Zerogram;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "zerogramjs",
+  "version": "2.1.0",
+  "description": "Framework moderno y elegante para crear bots de Telegram con Node.js.",
+  "main": "index.js",
+  "files": ["lib/", "shared/", "utils/", "index.js"],
+  "exports": {
+    ".": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["telegram", "bot", "telegram-bot-api", "nodejs"],
+  "author": "UserZero075",
+  "license": "MIT",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/UserZero075/ZerogramJS.git"
+  },
+  "bugs": {
+    "url": "https://github.com/UserZero075/ZerogramJS/issues"
+  },
+  "homepage": "https://github.com/UserZero075/ZerogramJS#readme"
+}

package/shared/downloadState.js

@@ -0,0 +1,9 @@
+/**
+ * Estado compartido para controladores de descarga
+ * Permite cancelar descargas en curso
+ */
+const downloadControllers = new Map();
+
+module.exports = {
+    downloadControllers
+};

package/utils/ffmpeg.js

@@ -0,0 +1,152 @@
+const { spawn, spawnSync } = require('child_process');
+const debug = require('debug')('zerogram:ffmpeg');
+
+/**
+ * Utilidades para trabajar con FFmpeg
+ */
+class FFMpegUtil {
+    constructor(ffmpegPath, ffprobePath) {
+        this.ffmpegPath = ffmpegPath;
+        this.ffprobePath = ffprobePath;
+    }
+
+    /**
+     * Detecta si un binario existe
+     * @private
+     */
+    static _bin(cmd, env) {
+        if (process.env[env]) {
+            return process.env[env];
+        }
+
+        try {
+            const result = spawnSync(cmd, ['-version'], { stdio: 'ignore' });
+            return !result.error && result.status === 0 ? cmd : null;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Crea una instancia auto-detectando binarios
+     * @static
+     */
+    static create() {
+        const ffmpegPath = FFMpegUtil._bin('ffmpeg', 'FFMPEG_PATH');
+        const ffprobePath = FFMpegUtil._bin('ffprobe', 'FFPROBE_PATH');
+
+        if (!ffmpegPath) {
+            debug('FFmpeg not found in PATH');
+        }
+        if (!ffprobePath) {
+            debug('FFprobe not found in PATH');
+        }
+
+        return new FFMpegUtil(ffmpegPath, ffprobePath);
+    }
+
+    /**
+     * Obtiene la duración de un video
+     * @param {Buffer} buffer - Buffer del video
+     * @param {number} timeout - Timeout en ms
+     * @returns {Promise<number>} Duración en segundos
+     */
+    duration(buffer, timeout = 8000) {
+        if (!this.ffprobePath) {
+            debug('ffprobe not available');
+            return Promise.resolve(0);
+        }
+
+        return new Promise((resolve) => {
+            const process = spawn(this.ffprobePath, [
+                '-v', 'error',
+                '-show_entries', 'format=duration',
+                '-of', 'default=nw=1:nk=1',
+                'pipe:0'
+            ]);
+
+            let output = '';
+            const timer = setTimeout(() => {
+                process.kill('SIGKILL');
+                resolve(0);
+            }, timeout);
+
+            process.stdout.on('data', (chunk) => {
+                output += chunk.toString();
+            });
+
+            process.on('close', () => {
+                clearTimeout(timer);
+                const duration = parseFloat(output.trim());
+                resolve(Number.isFinite(duration) ? duration : 0);
+            });
+
+            process.on('error', (err) => {
+                debug('ffprobe error:', err);
+                clearTimeout(timer);
+                resolve(0);
+            });
+
+            process.stdin.write(buffer);
+            process.stdin.end();
+        });
+    }
+
+    /**
+     * Genera un thumbnail de un video
+     * @param {Buffer} buffer - Buffer del video
+     * @param {Object} opts - Opciones
+     * @param {number} opts.seek - Posición en segundos
+     * @param {number} opts.width - Ancho del thumbnail
+     * @param {number} opts.timeout - Timeout en ms
+     * @returns {Promise<Buffer>} Buffer de la imagen
+     */
+    thumbnail(buffer, opts = {}) {
+        const { seek = 0.5, width = 320, timeout = 12000 } = opts;
+
+        if (!this.ffmpegPath) {
+            throw new Error('FFmpeg binary not found');
+        }
+
+        return new Promise((resolve, reject) => {
+            const process = spawn(this.ffmpegPath, [
+                '-i', 'pipe:0',
+                '-ss', `${seek}`,
+                '-frames:v', '1',
+                '-q:v', '2',
+                '-vf', `scale=${width}:-1`,
+                '-f', 'image2',
+                'pipe:1'
+            ]);
+
+            const chunks = [];
+            const timer = setTimeout(() => {
+                process.kill('SIGKILL');
+                reject(new Error('FFmpeg timeout'));
+            }, timeout);
+
+            process.stdout.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+
+            process.on('error', (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+
+            process.on('close', (code) => {
+                clearTimeout(timer);
+                if (code === 0) {
+                    resolve(Buffer.concat(chunks));
+                } else {
+                    reject(new Error(`FFmpeg exited with code ${code}`));
+                }
+            });
+
+            process.stdin.write(buffer);
+            process.stdin.end();
+        });
+    }
+}
+
+module.exports = { FFMpegUtil };

package/utils/loader.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const path = require('path');
+const debug = require('debug')('zerogram:loader');
+
+/**
+ * Carga módulos automáticamente desde un directorio
+ * @param {string} dir - Directorio a escanear
+ * @param {string} mode - 'command' o 'callback'
+ * @param {Function} inject - Función para registrar el módulo
+ */
+async function loadModules(dir, mode, inject) {
+    if (!fs.existsSync(dir)) {
+        debug(`Directory not found: ${dir}`);
+        return;
+    }
+
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.js'));
+    debug(`Loading ${files.length} modules from ${dir}`);
+
+    for (const file of files) {
+        const modulePath = path.join(dir, file);
+        const moduleName = file.replace(/\.js$/, '');
+
+        try {
+            const mod = require(modulePath);
+
+            if (mode === 'command') {
+                loadCommand(moduleName, mod, inject);
+            } else if (mode === 'callback') {
+                loadCallbacks(file, mod, inject);
+            }
+        } catch (error) {
+            console.error(`❌ Error loading ${file}:`, error.message);
+        }
+    }
+}
+
+/**
+ * Carga un módulo de comando
+ * @private
+ */
+function loadCommand(name, mod, inject) {
+    if (typeof mod === 'function') {
+        inject(name, mod);
+        debug(`✅ Command loaded: ${name}`);
+    } else if (typeof mod.default === 'function') {
+        inject(name, mod.default);
+        debug(`✅ Command loaded: ${name} (default export)`);
+    } else {
+        debug(`⚠️  Skipped ${name}: not a function`);
+    }
+}
+
+/**
+ * Carga callbacks de un módulo
+ * @private
+ */
+function loadCallbacks(fileName, mod, inject) {
+    debug(`📂 Loading callbacks from ${fileName}:`);
+
+    Object.entries(mod).forEach(([key, fn]) => {
+        if (typeof fn === 'function') {
+            inject(key, fn);
+            debug(`  ✅ Callback registered: ${key}`);
+        } else {
+            debug(`  ⚠️  Skipped ${key}: not a function`);
+        }
+    });
+}
+
+module.exports = { loadModules };

package/utils/markdown.js

@@ -0,0 +1,55 @@
+function parseMarkdown(text) {
+    // Placeholder — usa HTML directamente en telegram
+    return { cleanedText: text, entities: [] };
+}
+
+/**
+ * Convierte markdown a HTML
+ */
+function markdownToHtml(text) {
+    return text
+        // Links: [text](url)
+        .replace(/\[(.+?)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
+        // Bold: **text** or __text__
+        .replace(/\*\*(.*?)\*\*/g, '<b>$1</b>')
+        .replace(/__(.*?)__/g, '<i>$1</i>')
+        // Italic: *text*
+        .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<i>$1</i>')
+        // Strikethrough: ~~text~~
+        .replace(/~~(.*?)~~/g, '<strike>$1</strike>')
+        // Code: `text`
+        .replace(/`([^`]+)`/g, '<code>$1</code>')
+        // Code block: ```text```
+        .replace(/```(\w+)?\n([\s\S]*?)```/g, '<pre>$2</pre>')
+        // Lists
+        .replace(/^• /gm, '• ')
+}
+
+/**
+ * Convierte markdown a MarkdownV2
+ */
+function markdownToMarkdownV2(text) {
+    function escapeMarkdownV2(str) {
+        return str.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, '\\$1')
+    }
+
+    return text
+        // Links: [text](url)
+        .replace(/\[(.+?)\]\((https?:\/\/[^)]+)\)/g, ($0, text, url) => `[${escapeMarkdownV2(text)}](${url})`)
+        // Code block: ```text``` (process before inline code)
+        .replace(/```(\w+)?\n([\s\S]*?)```/g, ($0, lang, code) => `\`${code.replace(/`/g, '')}\``)
+        // Bold: **text**
+        .replace(/\*\*(.*?)\*\*/g, '*$1*')
+        // Italic: *text*
+        .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '_$1_')
+        // Code: `text`
+        .replace(/`([^`]+)`/g, '`$1`')
+        // Escape remaining special chars
+        .replace(/([_\*\[\]()~`>#+\-=|{}.!\\])/g, '\\$1')
+}
+
+module.exports = {
+    parseMarkdown,
+    markdownToHtml,
+    markdownToMarkdownV2
+}