evogram-gramjs 1.0.0

package/lib/services/ImageUploadService.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageUploadService = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
+/**
+ * Сервис для загрузки изображений на внешние хостинги
+ */
+class ImageUploadService {
+    /**
+     * Загружает изображение на imgbox.vu/uploads
+     *
+     * @param imageBuffer Буфер изображения
+     * @param filename Имя файла (опционально)
+     * @returns Promise с URL загруженного изображения
+     * @throws Error если загрузка не удалась
+     */
+    static uploadToImgbox(imageBuffer, filename) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const formData = new form_data_1.default();
+                formData.append('file', imageBuffer, {
+                    filename: filename || 'avatar.jpg',
+                    contentType: 'image/jpeg',
+                });
+                const response = yield axios_1.default.post(this.UPLOAD_URL, formData, {
+                    headers: formData.getHeaders(),
+                });
+                const result = response.data;
+                // Проверяем формат ответа imgbox.vu
+                // API может возвращать URL в разных форматах, нужно проверить структуру ответа
+                if (result.url) {
+                    return result.url;
+                }
+                else if ((_a = result.data) === null || _a === void 0 ? void 0 : _a.url) {
+                    return result.data.url;
+                }
+                else if (typeof result === 'string' && result.startsWith('http')) {
+                    return result;
+                }
+                else {
+                    // Если формат ответа неизвестен, возвращаем весь ответ как строку для отладки
+                    throw new Error(`Неожиданный формат ответа от imgbox.vu: ${JSON.stringify(result)}`);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`Ошибка загрузки изображения на imgbox.vu: ${errorMessage}`);
+            }
+        });
+    }
+}
+exports.ImageUploadService = ImageUploadService;
+ImageUploadService.UPLOAD_URL = 'https://imgbox.vu/uploads';

package/lib/sessions/Session.d.ts

@@ -0,0 +1,13 @@
+import { TelegramClient } from 'telegram';
+import { SessionAuth } from './SessionAuth';
+import { SessionLogger } from './SessionLogger';
+export declare class Session {
+    readonly sessionId: string;
+    readonly client: TelegramClient;
+    readonly logger: SessionLogger | undefined;
+    /** Объект авторизации для сессии */
+    auth: SessionAuth;
+    constructor(sessionId: string, client: TelegramClient, logger: SessionLogger | undefined, auth: SessionAuth);
+    db(): Promise<import("..").Session | null>;
+    user(): Promise<import("telegram").Api.User>;
+}

package/lib/sessions/Session.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const tslib_1 = require("tslib");
+const EvogramGramJS_1 = require("../EvogramGramJS");
+class Session {
+    constructor(sessionId, client, logger, auth) {
+        this.sessionId = sessionId;
+        this.client = client;
+        this.logger = logger;
+        this.auth = auth;
+    }
+    db() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = (yield EvogramGramJS_1.EvogramGramJS.databaseService.getSession(this.sessionId))) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    user() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.client.getMe();
+        });
+    }
+}
+exports.Session = Session;

package/lib/sessions/SessionAuth.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from 'events';
+import { TelegramClient } from 'telegram';
+import { AuthState } from '../types/auth.types';
+import { Deferred } from '../utils/Deferrer';
+import { SessionLogger } from './SessionLogger';
+/**
+ * События авторизации для сессии
+ */
+export declare enum SessionAuthEvent {
+    /** Начало авторизации */
+    AUTH_STARTED = "auth:started",
+    /** Код отправлен */
+    CODE_SENT = "auth:code_sent",
+    /** Код получен */
+    CODE_RECEIVED = "auth:code_received",
+    /** Требуется пароль */
+    PASSWORD_REQUIRED = "auth:password_required",
+    /** Авторизация успешна */
+    AUTH_SUCCESS = "auth:success",
+    /** Ошибка авторизации */
+    AUTH_ERROR = "auth:error",
+    /** Авторизация отменена */
+    AUTH_CANCELLED = "auth:cancelled"
+}
+/**
+ * Класс авторизации для конкретной сессии
+ * Предоставляет методы авторизации, привязанные к сессии
+ */
+export declare class SessionAuth extends EventEmitter {
+    private readonly sessionId;
+    private readonly client;
+    private readonly logger?;
+    state: {
+        code: Deferred<string>;
+        password: Deferred<string>;
+        isRequiredPassword: boolean;
+        stage: AuthState;
+        connect: Deferred<boolean>;
+    };
+    constructor(sessionId: string, client: TelegramClient, logger?: SessionLogger | undefined);
+    start(phoneNumber: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: unknown;
+    }>;
+    setCode(code: string): Promise<{
+        success: boolean;
+        error: Error;
+    }>;
+    setPassword(password: string): Promise<{
+        success: boolean;
+        error: Error;
+    }>;
+    /**
+     * Проверяет, требуется ли пароль для авторизации
+     *
+     * @returns true, если требуется пароль
+     */
+    isRequiredPassword(): Promise<boolean>;
+}

package/lib/sessions/SessionAuth.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAuth = exports.SessionAuthEvent = void 0;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const EvogramGramJS_1 = require("../EvogramGramJS");
+const ImageUploadService_1 = require("../services/ImageUploadService");
+const auth_types_1 = require("../types/auth.types");
+const Deferrer_1 = require("../utils/Deferrer");
+/**
+ * События авторизации для сессии
+ */
+var SessionAuthEvent;
+(function (SessionAuthEvent) {
+    /** Начало авторизации */
+    SessionAuthEvent["AUTH_STARTED"] = "auth:started";
+    /** Код отправлен */
+    SessionAuthEvent["CODE_SENT"] = "auth:code_sent";
+    /** Код получен */
+    SessionAuthEvent["CODE_RECEIVED"] = "auth:code_received";
+    /** Требуется пароль */
+    SessionAuthEvent["PASSWORD_REQUIRED"] = "auth:password_required";
+    /** Авторизация успешна */
+    SessionAuthEvent["AUTH_SUCCESS"] = "auth:success";
+    /** Ошибка авторизации */
+    SessionAuthEvent["AUTH_ERROR"] = "auth:error";
+    /** Авторизация отменена */
+    SessionAuthEvent["AUTH_CANCELLED"] = "auth:cancelled";
+})(SessionAuthEvent || (exports.SessionAuthEvent = SessionAuthEvent = {}));
+/**
+ * Класс авторизации для конкретной сессии
+ * Предоставляет методы авторизации, привязанные к сессии
+ */
+class SessionAuth extends events_1.EventEmitter {
+    constructor(sessionId, client, logger) {
+        super();
+        this.sessionId = sessionId;
+        this.client = client;
+        this.logger = logger;
+        this.state = null;
+    }
+    start(phoneNumber) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.state)
+                throw new Error(`Авторизация для сессии "${this.sessionId}" уже начата`);
+            this.state = {
+                code: new Deferrer_1.Deferred(),
+                password: new Deferrer_1.Deferred(),
+                isRequiredPassword: false,
+                stage: auth_types_1.AuthState.INITIAL,
+                connect: new Deferrer_1.Deferred(),
+            };
+            try {
+                yield new Promise((res, rej) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield this.client
+                        .start({
+                        phoneNumber,
+                        phoneCode: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            res(true);
+                            this.state.stage = auth_types_1.AuthState.WAITING_CODE;
+                            const code = yield this.state.code.promise;
+                            this.state.code = new Deferrer_1.Deferred();
+                            return code;
+                        }),
+                        password: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            this.state.isRequiredPassword = true;
+                            this.state.stage = auth_types_1.AuthState.WAITING_PASSWORD;
+                            const password = yield this.state.password.promise;
+                            this.state.password = new Deferrer_1.Deferred();
+                            return password;
+                        }),
+                        onError: (error) => {
+                            this.state.stage = auth_types_1.AuthState.ERROR;
+                            this.emit(SessionAuthEvent.AUTH_ERROR, {
+                                sessionId: this.sessionId,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        },
+                    })
+                        .catch(rej);
+                    try {
+                        const me = yield this.client.getMe();
+                        this.state.connect.resolve(true);
+                        let avatarBuffer = yield this.client.downloadProfilePhoto('me'), avatarUrl;
+                        if (avatarBuffer)
+                            avatarUrl = yield ImageUploadService_1.ImageUploadService.uploadToImgbox(Buffer.isBuffer(avatarBuffer) ? avatarBuffer : Buffer.from(avatarBuffer));
+                        yield EvogramGramJS_1.EvogramGramJS.databaseService.saveSession({
+                            sessionId: this.sessionId,
+                            apiId: this.client.apiId,
+                            apiHash: this.client.apiHash,
+                            userId: Number(me.id),
+                            username: me.username,
+                            firstName: me.firstName,
+                            lastName: me.lastName,
+                            phoneNumber: me.phone,
+                            sessionString: this.client.session.save(),
+                            avatarUrl,
+                        });
+                    }
+                    catch (_a) { }
+                }));
+                return {
+                    success: true,
+                };
+            }
+            catch (error) {
+                this.emit(SessionAuthEvent.AUTH_ERROR, {
+                    sessionId: this.sessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return {
+                    success: false,
+                    error,
+                };
+            }
+        });
+    }
+    setCode(code) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.state)
+                throw new Error(`Авторизация для сессии "${this.sessionId}" не начата`);
+            const errorPromise = new Promise((resolve, reject) => {
+                this.once(SessionAuthEvent.AUTH_ERROR, (data) => data.sessionId === this.sessionId && resolve(data.error));
+                setTimeout(resolve, 1000);
+            });
+            this.state.code.resolve(code);
+            const error = yield errorPromise;
+            return {
+                success: error ? false : true,
+                error: error || undefined,
+            };
+        });
+    }
+    setPassword(password) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.state)
+                throw new Error(`Авторизация для сессии "${this.sessionId}" не начата`);
+            const errorPromise = new Promise((resolve, reject) => {
+                this.once(SessionAuthEvent.AUTH_ERROR, (data) => data.sessionId === this.sessionId && resolve(data.error));
+                setTimeout(resolve, 1000);
+            });
+            this.state.password.resolve(password);
+            const error = yield errorPromise;
+            return {
+                success: error ? false : true,
+                error: error || undefined,
+            };
+        });
+    }
+    /**
+     * Проверяет, требуется ли пароль для авторизации
+     *
+     * @returns true, если требуется пароль
+     */
+    isRequiredPassword() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if ((_a = this.state) === null || _a === void 0 ? void 0 : _a.isRequiredPassword)
+                return true;
+            yield new Promise((resolve) => setTimeout(resolve, 1000));
+            return (_c = (_b = this.state) === null || _b === void 0 ? void 0 : _b.isRequiredPassword) !== null && _c !== void 0 ? _c : false;
+        });
+    }
+}
+exports.SessionAuth = SessionAuth;

package/lib/sessions/SessionLogger.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Логгер для отдельной сессии
+ * Записывает все действия и активность сессии в отдельный файл
+ */
+export declare class SessionLogger {
+    private readonly sessionId;
+    private readonly logsDirectory;
+    private logStream;
+    private logFilePath;
+    private isInitialized;
+    /**
+     * @param sessionId Идентификатор сессии
+     * @param logsDirectory Директория для хранения логов (по умолчанию './logs')
+     */
+    constructor(sessionId: string, logsDirectory?: string);
+    /**
+     * Инициализирует логгер (создает директорию и файл)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Записывает лог-запись в файл
+     *
+     * @param level Уровень логирования (INFO, WARN, ERROR, DEBUG)
+     * @param message Сообщение для логирования
+     * @param data Дополнительные данные (опционально)
+     */
+    log(level: 'INFO' | 'WARN' | 'ERROR' | 'DEBUG', message: string, data?: any): void;
+    /**
+     * Логирует информацию
+     */
+    info(message: string, data?: any): void;
+    /**
+     * Логирует предупреждение
+     */
+    warn(message: string, data?: any): void;
+    /**
+     * Логирует ошибку
+     */
+    error(message: string, error?: Error | any): void;
+    /**
+     * Логирует отладочную информацию
+     */
+    debug(message: string, data?: any): void;
+    /**
+     * Логирует действие сессии
+     *
+     * @param action Название действия
+     * @param details Детали действия
+     */
+    logAction(action: string, details?: any): void;
+    /**
+     * Логирует событие от Telegram клиента
+     *
+     * @param eventName Название события
+     * @param eventData Данные события
+     */
+    logTelegramEvent(eventName: string, eventData?: any): void;
+    /**
+     * Закрывает поток записи
+     */
+    close(): Promise<void>;
+    /**
+     * Получает путь к файлу лога
+     */
+    getLogFilePath(): string;
+    /**
+     * Внутренний метод для записи в файл
+     *
+     * @private
+     */
+    private writeLog;
+    /**
+     * Форматирует запись лога для записи в файл
+     *
+     * @private
+     */
+    private formatLogEntry;
+    /**
+     * Очищает имя файла от недопустимых символов
+     *
+     * @private
+     */
+    private sanitizeFileName;
+}

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,79 @@
+import { EventEmitter } from 'events';
+import { TelegramClient } from 'telegram';
+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[];
+    /**
+     * Получает список всех ID сессий
+     *
+     * @returns Массив идентификаторов сессий
+     */
+    getAllSessionIds(): string[];
+    /**
+     * Проверяет, существует ли сессия с указанным ID
+     *
+     * @param sessionId Идентификатор сессии
+     * @returns true, если сессия существует, иначе false
+     */
+    hasSession(sessionId: string): boolean;
+    /**
+     * Получает количество активных сессий
+     *
+     * @returns Количество сессий
+     */
+    getSessionCount(): number;
+}