evogram-gramjs 1.1.0 → 1.1.1

package/lib/sessions/SessionLogger.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionLogger = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Логгер для отдельной сессии
+ * Записывает все действия и активность сессии в отдельный файл
+ */
+class SessionLogger {
+    /**
+     * @param sessionId Идентификатор сессии
+     * @param logsDirectory Директория для хранения логов (по умолчанию './logs')
+     */
+    constructor(sessionId, logsDirectory = './logs') {
+        this.sessionId = sessionId;
+        this.logsDirectory = logsDirectory;
+        this.logStream = null;
+        this.isInitialized = false;
+        // Формируем путь к файлу лога
+        const sanitizedSessionId = this.sanitizeFileName(sessionId);
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        this.logFilePath = (0, path_1.join)(this.logsDirectory, `session-${sanitizedSessionId}-${timestamp}.log`);
+    }
+    /**
+     * Инициализирует логгер (создает директорию и файл)
+     */
+    initialize() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isInitialized)
+                return;
+            try {
+                // Создаем директорию для логов, если её нет
+                yield (0, promises_1.mkdir)(this.logsDirectory, { recursive: true });
+                // Создаем поток записи в файл (режим append)
+                this.logStream = (0, fs_1.createWriteStream)(this.logFilePath, { flags: 'a' });
+                // Записываем заголовок
+                this.writeLog('INFO', `Логгер инициализирован для сессии: ${this.sessionId}`);
+                this.writeLog('INFO', `Файл лога: ${this.logFilePath}`);
+                this.writeLog('INFO', `Время создания: ${new Date().toISOString()}`);
+                this.writeLog('INFO', '─'.repeat(80));
+                this.isInitialized = true;
+            }
+            catch (error) {
+                console.error(`Ошибка инициализации логгера для сессии ${this.sessionId}:`, error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Записывает лог-запись в файл
+     *
+     * @param level Уровень логирования (INFO, WARN, ERROR, DEBUG)
+     * @param message Сообщение для логирования
+     * @param data Дополнительные данные (опционально)
+     */
+    log(level, message, data) {
+        if (!this.isInitialized) {
+            // Если логгер еще не инициализирован, инициализируем синхронно
+            this.initialize().catch((error) => {
+                console.error(`Ошибка инициализации логгера:`, error);
+            });
+            return;
+        }
+        this.writeLog(level, message, data);
+    }
+    /**
+     * Логирует информацию
+     */
+    info(message, data) {
+        this.log('INFO', message, data);
+    }
+    /**
+     * Логирует предупреждение
+     */
+    warn(message, data) {
+        this.log('WARN', message, data);
+    }
+    /**
+     * Логирует ошибку
+     */
+    error(message, error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : undefined;
+        this.log('ERROR', message, { error: errorMessage, stack: errorStack });
+    }
+    /**
+     * Логирует отладочную информацию
+     */
+    debug(message, data) {
+        this.log('DEBUG', message, data);
+    }
+    /**
+     * Логирует действие сессии
+     *
+     * @param action Название действия
+     * @param details Детали действия
+     */
+    logAction(action, details) {
+        this.info(`Действие: ${action}`, details);
+    }
+    /**
+     * Логирует событие от Telegram клиента
+     *
+     * @param eventName Название события
+     * @param eventData Данные события
+     */
+    logTelegramEvent(eventName, eventData) {
+        this.debug(`Telegram событие: ${eventName}`, eventData);
+    }
+    /**
+     * Закрывает поток записи
+     */
+    close() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.logStream) {
+                this.writeLog('INFO', '─'.repeat(80));
+                this.writeLog('INFO', `Логгер закрыт для сессии: ${this.sessionId}`);
+                this.writeLog('INFO', `Время закрытия: ${new Date().toISOString()}`);
+                return new Promise((resolve, reject) => {
+                    this.logStream.end((error) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            this.logStream = null;
+                            this.isInitialized = false;
+                            resolve();
+                        }
+                    });
+                });
+            }
+        });
+    }
+    /**
+     * Получает путь к файлу лога
+     */
+    getLogFilePath() {
+        return this.logFilePath;
+    }
+    /**
+     * Внутренний метод для записи в файл
+     *
+     * @private
+     */
+    writeLog(level, message, data) {
+        if (!this.logStream) {
+            // Если поток еще не создан, выводим в консоль
+            console.log(`[${this.sessionId}] [${level}] ${message}`, data || '');
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const logEntry = {
+            timestamp,
+            level,
+            sessionId: this.sessionId,
+            message,
+        };
+        if (data !== undefined) {
+            logEntry.data = data;
+        }
+        // Форматируем запись для удобного чтения
+        const logLine = this.formatLogEntry(logEntry);
+        this.logStream.write(logLine + '\n');
+    }
+    /**
+     * Форматирует запись лога для записи в файл
+     *
+     * @private
+     */
+    formatLogEntry(entry) {
+        const { timestamp, level, message, data } = entry;
+        let logLine = `[${timestamp}] [${level}] ${message}`;
+        if (data !== undefined) {
+            try {
+                const dataStr = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+                logLine += `\n${dataStr}`;
+            }
+            catch (error) {
+                logLine += `\n[Не удалось сериализовать данные]`;
+            }
+        }
+        return logLine;
+    }
+    /**
+     * Очищает имя файла от недопустимых символов
+     *
+     * @private
+     */
+    sanitizeFileName(fileName) {
+        return fileName.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+}
+exports.SessionLogger = SessionLogger;

package/lib/sessions/SessionManager.d.ts

@@ -0,0 +1,84 @@
+import { EventEmitter } from 'events';
+import { Api, TelegramClient } from 'telegram';
+import { Session as SessionEntity } from '../entities/Session.entity';
+import { DatabaseService } from '../services/DatabaseService';
+import { SessionConfig, SessionInfo } from '../types/session.types';
+import { SessionLogger } from './SessionLogger';
+/**
+ * Сервис для управления множеством сессий Telegram клиентов
+ *
+ * Предоставляет удобный API для:
+ * - Добавления и удаления сессий
+ * - Получения информации о сессиях
+ * - Отслеживания событий (подключение, отключение, ошибки)
+ * - Сохранения данных в базе данных
+ */
+export declare class SessionManager extends EventEmitter {
+    private readonly TELEGRAM_APP_ID;
+    private readonly TELEGRAM_APP_HASH;
+    private readonly databaseService?;
+    constructor(TELEGRAM_APP_ID: number, TELEGRAM_APP_HASH: string, databaseService?: DatabaseService | undefined);
+    /** Хранилище всех активных сессий */
+    private sessions;
+    initialize(): Promise<void>;
+    /**
+     * Добавляет новую сессию
+     *
+     * @param config Конфигурация сессии
+     * @returns Promise с информацией о созданной сессии
+     * @throws Error если сессия с таким ID уже существует
+     */
+    addSession(config: SessionConfig): Promise<SessionInfo>;
+    disconnectSession(sessionId: string): Promise<void>;
+    getActiveSessions(): Promise<SessionInfo[]>;
+    /**
+     * Получает информацию о сессии по ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns Информация о сессии или undefined, если не найдена
+     */
+    getSession(sessionId: string): SessionInfo | undefined;
+    /**
+     * Получает Telegram клиент по ID сессии
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns Telegram клиент или undefined, если сессия не найдена
+     */
+    getClient(sessionId: string): TelegramClient | undefined;
+    /**
+     * Получает логгер сессии по ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns Логгер сессии или undefined, если сессия не найдена или логирование отключено
+     */
+    getLogger(sessionId: string): SessionLogger | undefined;
+    /**
+     * Получает все активные сессии
+     *
+     * @returns Массив информации о всех сессиях
+     */
+    getAllSessions(): SessionInfo[];
+    getAllLoadedSessions(): Promise<({
+        db: SessionEntity | null;
+        user: Api.User | null;
+    } & Omit<SessionInfo, 'db' | 'user'>)[]>;
+    /**
+     * Получает список всех ID сессий
+     *
+     * @returns Массив идентификаторов сессий
+     */
+    getAllSessionIds(): string[];
+    /**
+     * Проверяет, существует ли сессия с указанным ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns true, если сессия существует, иначе false
+     */
+    hasSession(sessionId: string): boolean;
+    /**
+     * Получает количество активных сессий
+     *
+     * @returns Количество сессий
+     */
+    getSessionCount(): number;
+}

package/lib/sessions/SessionManager.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const telegram_1 = require("telegram");
+const network_1 = require("telegram/network");
+const sessions_1 = require("telegram/sessions");
+const EvogramGramJS_1 = require("../EvogramGramJS");
+const session_types_1 = require("../types/session.types");
+const Session_1 = require("./Session");
+const SessionAuth_1 = require("./SessionAuth");
+/**
+ * Сервис для управления множеством сессий Telegram клиентов
+ *
+ * Предоставляет удобный API для:
+ * - Добавления и удаления сессий
+ * - Получения информации о сессиях
+ * - Отслеживания событий (подключение, отключение, ошибки)
+ * - Сохранения данных в базе данных
+ */
+class SessionManager extends events_1.EventEmitter {
+    constructor(TELEGRAM_APP_ID, TELEGRAM_APP_HASH, databaseService) {
+        super();
+        this.TELEGRAM_APP_ID = TELEGRAM_APP_ID;
+        this.TELEGRAM_APP_HASH = TELEGRAM_APP_HASH;
+        this.databaseService = databaseService;
+        /** Хранилище всех активных сессий */
+        this.sessions = new Map();
+    }
+    initialize() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sessions = yield ((_a = this.databaseService) === null || _a === void 0 ? void 0 : _a.getSessions());
+            if (!sessions || sessions.length === 0)
+                return;
+            for (const session of sessions) {
+                yield this.addSession({
+                    sessionId: session.sessionId,
+                    sessionString: session.sessionString,
+                    apiId: session.apiId,
+                    apiHash: session.apiHash,
+                    clientOptions: session.clientOptions ? JSON.parse(session.clientOptions) : undefined,
+                });
+            }
+        });
+    }
+    /**
+     * Добавляет новую сессию
+     *
+     * @param config Конфигурация сессии
+     * @returns Promise с информацией о созданной сессии
+     * @throws Error если сессия с таким ID уже существует
+     */
+    addSession(config) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            // Проверяем, не существует ли уже сессия с таким ID в памяти
+            if (this.sessions.has(config.sessionId))
+                return this.sessions.get(config.sessionId);
+            // Создаем строковую сессию (если не предоставлена, создается пустая)
+            const session = new sessions_1.StringSession(config.sessionString || '');
+            // Создаем Telegram клиент
+            const client = new telegram_1.TelegramClient(session, (_a = config.apiId) !== null && _a !== void 0 ? _a : this.TELEGRAM_APP_ID, (_b = config.apiHash) !== null && _b !== void 0 ? _b : this.TELEGRAM_APP_HASH, {
+                useIPV6: (_d = (_c = config.clientOptions) === null || _c === void 0 ? void 0 : _c.useIPV6) !== null && _d !== void 0 ? _d : false,
+                connectionRetries: (_f = (_e = config.clientOptions) === null || _e === void 0 ? void 0 : _e.connectionRetries) !== null && _f !== void 0 ? _f : 5,
+            });
+            yield client.connect();
+            client.addEventHandler((event) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d;
+                if ((_b = (yield ((_a = this.getSession(config.sessionId)) === null || _a === void 0 ? void 0 : _a.db()))) === null || _b === void 0 ? void 0 : _b.error)
+                    return;
+                else if (!((_d = (yield ((_c = this.getSession(config.sessionId)) === null || _c === void 0 ? void 0 : _c.db()))) === null || _d === void 0 ? void 0 : _d.sessionString))
+                    return;
+                if (event instanceof network_1.UpdateConnectionState) {
+                    const error = yield client
+                        .getMe()
+                        .then(() => undefined)
+                        .catch((error) => error);
+                    if (error) {
+                        this.emit(session_types_1.SessionEvent.SESSION_INVALID, {
+                            sessionId: config.sessionId,
+                            error: error,
+                        });
+                        yield EvogramGramJS_1.EvogramGramJS.databaseService.updateSession(config.sessionId, { error: error.errorMessage });
+                        yield this.disconnectSession(config.sessionId);
+                    }
+                }
+            }));
+            const sessionAuth = new SessionAuth_1.SessionAuth(config.sessionId, client);
+            const sessionInfo = new Session_1.Session(config.sessionId, client, undefined, sessionAuth);
+            this.sessions.set(config.sessionId, sessionInfo);
+            // Генерируем событие добавления сессии
+            this.emit(session_types_1.SessionEvent.SESSION_ADDED, {
+                sessionId: config.sessionId,
+                sessionInfo,
+            });
+            return sessionInfo;
+        });
+    }
+    disconnectSession(sessionId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.get(sessionId);
+            if (!session)
+                throw new Error(`Сессия с ID ${sessionId} не найдена`);
+            yield session.client.disconnect();
+            this.emit(session_types_1.SessionEvent.SESSION_DISCONNECTED, {
+                sessionId: sessionId,
+            });
+        });
+    }
+    getActiveSessions() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const sessions = Array.from(this.sessions.values());
+            const results = yield Promise.all(sessions.map((session) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const dbData = yield session.db();
+                return { session, hasError: !!(dbData === null || dbData === void 0 ? void 0 : dbData.error) };
+            })));
+            return results.filter((result) => !result.hasError).map((result) => result.session);
+        });
+    }
+    /**
+     * Получает информацию о сессии по ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns Информация о сессии или undefined, если не найдена
+     */
+    getSession(sessionId) {
+        const sessionInfo = this.sessions.get(sessionId);
+        return sessionInfo;
+    }
+    /**
+     * Получает Telegram клиент по ID сессии
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns Telegram клиент или undefined, если сессия не найдена
+     */
+    getClient(sessionId) {
+        var _a;
+        return (_a = this.getSession(sessionId)) === null || _a === void 0 ? void 0 : _a.client;
+    }
+    /**
+     * Получает логгер сессии по ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns Логгер сессии или undefined, если сессия не найдена или логирование отключено
+     */
+    getLogger(sessionId) {
+        var _a;
+        return (_a = this.getSession(sessionId)) === null || _a === void 0 ? void 0 : _a.logger;
+    }
+    /**
+     * Получает все активные сессии
+     *
+     * @returns Массив информации о всех сессиях
+     */
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    getAllLoadedSessions() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const sessions = Array.from(this.sessions.values());
+            const results = yield Promise.all(sessions
+                .filter((x) => x.sessionId)
+                .map((session) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return Object.assign(Object.assign({}, session), { db: yield session.db().catch(() => null), user: yield session.user().catch(() => null) });
+            })));
+            //@ts-ignore
+            return results;
+        });
+    }
+    /**
+     * Получает список всех ID сессий
+     *
+     * @returns Массив идентификаторов сессий
+     */
+    getAllSessionIds() {
+        return Array.from(this.sessions.keys());
+    }
+    /**
+     * Проверяет, существует ли сессия с указанным ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns true, если сессия существует, иначе false
+     */
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    /**
+     * Получает количество активных сессий
+     *
+     * @returns Количество сессий
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+}
+exports.SessionManager = SessionManager;

package/lib/test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const QRCode = tslib_1.__importStar(require("qrcode"));
+const telegram_1 = require("telegram");
+const EvogramGramJS_1 = require("./EvogramGramJS");
+const ImageUploadService_1 = require("./services/ImageUploadService");
+/**
+ * Пример авторизации через QR-код
+ */
+function authWithQRCode() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        EvogramGramJS_1.EvogramGramJS.initialize(29997404, '475e53e15bcb402f3a218e1141a585cf', {
+            type: 'sqlite',
+            database: './evogramjs.sqlite',
+            synchronize: true,
+        });
+        // Убедитесь, что EvogramGramJS инициализирован перед использованием
+        // EvogramGramJS.initialize(apiId, apiHash, databaseConfig)
+        const sessionId = `qr-auth-${Date.now()}`;
+        try {
+            // Создаем новую сессию
+            const session = yield EvogramGramJS_1.EvogramGramJS.sessionManager.addSession({
+                sessionId,
+                logging: {
+                    enabled: true,
+                    logsDirectory: './logs',
+                },
+            });
+            console.log('🔐 Начинаем авторизацию через QR-код...');
+            // Получаем API credentials из клиента
+            const apiCredentials = {
+                apiId: session.client.apiId,
+                apiHash: session.client.apiHash,
+            };
+            // Выполняем авторизацию через QR-код
+            const user = yield session.client.signInUserWithQrCode(apiCredentials, {
+                qrCode: (qrCode) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    // Преобразуем токен в URL для сканирования
+                    const qrToken = qrCode.token.toString('base64url');
+                    const qrUrl = `tg://login?token=${qrToken}`;
+                    console.log('\n📱 Отсканируйте QR-код в приложении Telegram:');
+                    console.log(`\n🔗 URL: ${qrUrl}`);
+                    console.log(`\n⏱️  QR-код действителен до: ${new Date(Date.now() + qrCode.expires * 1000).toLocaleString()}`);
+                    try {
+                        // Генерируем QR-код для терминала
+                        const qrCodeTerminal = yield QRCode.toString(qrUrl, { type: 'terminal', small: true });
+                        console.log('\n📱 QR-код (терминал):');
+                        console.log(qrCodeTerminal);
+                        // Генерируем QR-код как изображение PNG
+                        const qrCodeFileName = `qr-code-${sessionId}.png`;
+                        const qrCodeFilePath = path.join(process.cwd(), qrCodeFileName);
+                        yield QRCode.toFile(qrCodeFilePath, qrUrl, {
+                            type: 'png',
+                            width: 500,
+                            margin: 2,
+                            color: {
+                                dark: '#000000',
+                                light: '#FFFFFF',
+                            },
+                        });
+                        console.log(`\n💾 QR-код сохранен в файл: ${qrCodeFilePath}`);
+                        console.log(`\n💡 Откройте файл и отсканируйте QR-код в приложении Telegram`);
+                    }
+                    catch (error) {
+                        console.error('⚠️  Ошибка при генерации QR-кода:', error);
+                        console.log('\n💡 Вы можете использовать URL выше для генерации QR-кода вручную');
+                    }
+                }),
+                password: (hint) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    // Если требуется пароль 2FA
+                    console.log(`\n🔒 Требуется пароль 2FA${hint ? ` (подсказка: ${hint})` : ''}`);
+                    // В реальном приложении здесь нужно запросить пароль у пользователя
+                    // Для примера возвращаем пустую строку (это вызовет ошибку)
+                    throw new Error('Пароль 2FA не предоставлен. Реализуйте логику получения пароля.');
+                }),
+                onError: (error) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    console.error('\n❌ Ошибка авторизации:', error.message);
+                    // Возвращаем false, чтобы продолжить попытки авторизации
+                    return false;
+                }),
+            });
+            console.log('\n✅ Авторизация успешна!');
+            // Проверяем, что это реальный пользователь, а не UserEmpty
+            if (!(user instanceof telegram_1.Api.User)) {
+                throw new Error('Получен неверный тип пользователя');
+            }
+            console.log(`👤 Пользователь: ${user.firstName || ''} ${user.lastName || ''} (@${user.username || 'без username'})`);
+            console.log(`📞 Телефон: ${user.phone || 'не указан'}`);
+            // Сохраняем сессию в базу данных
+            try {
+                let avatarBuffer = yield session.client.downloadProfilePhoto('me');
+                let avatarUrl;
+                if (avatarBuffer) {
+                    avatarUrl = yield ImageUploadService_1.ImageUploadService.uploadToImgbox(Buffer.isBuffer(avatarBuffer) ? avatarBuffer : Buffer.from(avatarBuffer));
+                }
+                yield EvogramGramJS_1.EvogramGramJS.databaseService.saveSession({
+                    sessionId: session.sessionId,
+                    apiId: session.client.apiId,
+                    apiHash: session.client.apiHash,
+                    userId: Number(user.id),
+                    username: user.username,
+                    firstName: user.firstName,
+                    lastName: user.lastName,
+                    phoneNumber: user.phone,
+                    sessionString: session.client.session.save(),
+                    avatarUrl,
+                });
+                console.log('💾 Сессия сохранена в базу данных');
+            }
+            catch (error) {
+                console.error('⚠️  Ошибка при сохранении сессии:', error);
+            }
+            return {
+                success: true,
+                user,
+                sessionId: session.sessionId,
+            };
+        }
+        catch (error) {
+            console.error('\n❌ Критическая ошибка:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    });
+}
+// Запускаем авторизацию
+authWithQRCode()
+    .then((result) => {
+    if (result.success) {
+        console.log('\n🎉 Авторизация завершена успешно!');
+    }
+    else {
+        console.log('\n💥 Авторизация не удалась');
+    }
+    process.exit(0);
+})
+    .catch((error) => {
+    console.error('💥 Необработанная ошибка:', error);
+    process.exit(1);
+});