evogram-gramjs 1.1.0 → 1.1.1

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,72 @@
+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;
+    }>;
+    /**
+     * Начинает авторизацию через QR-код
+     *
+     * @param onQRCode Callback для обработки QR-кода (получает URL и токен)
+     * @returns Promise с результатом авторизации
+     */
+    startWithQRCode(onQRCode: (qrUrl: string, qrToken: string, expires: number) => Promise<void>): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Проверяет, требуется ли пароль для авторизации
+     *
+     * @returns true, если требуется пароль
+     */
+    isRequiredPassword(): Promise<boolean>;
+}

package/lib/sessions/SessionAuth.js

@@ -0,0 +1,327 @@
+"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 telegram_1 = require("telegram");
+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,
+            };
+        });
+    }
+    /**
+     * Начинает авторизацию через QR-код
+     *
+     * @param onQRCode Callback для обработки QR-кода (получает URL и токен)
+     * @returns Promise с результатом авторизации
+     */
+    startWithQRCode(onQRCode) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            console.log(`[QR-AUTH] Начало метода startWithQRCode для сессии "${this.sessionId}"`);
+            console.log(`[QR-AUTH] Текущее состояние state:`, this.state ? 'уже инициализировано' : 'null');
+            if (this.state)
+                throw new Error(`Авторизация для сессии "${this.sessionId}" уже начата`);
+            console.log(`[QR-AUTH] Инициализация state для сессии "${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(),
+            };
+            console.log(`[QR-AUTH] State успешно инициализирован:`, {
+                stage: this.state.stage,
+                isRequiredPassword: this.state.isRequiredPassword,
+            });
+            try {
+                console.log(`[QR-AUTH] Получение API credentials для клиента`);
+                const apiCredentials = {
+                    apiId: this.client.apiId,
+                    apiHash: this.client.apiHash,
+                };
+                console.log(`[QR-AUTH] API credentials:`, {
+                    apiId: apiCredentials.apiId,
+                    apiHashLength: ((_a = apiCredentials.apiHash) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                });
+                console.log(`[QR-AUTH] Смена стадии на WAITING_CODE`);
+                this.state.stage = auth_types_1.AuthState.WAITING_CODE;
+                console.log(`[QR-AUTH] Текущая стадия:`, this.state.stage);
+                console.log(`[QR-AUTH] Вызов client.signInUserWithQrCode для сессии "${this.sessionId}"`);
+                const user = yield this.client.signInUserWithQrCode(apiCredentials, {
+                    qrCode: (qrCode) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        console.log(`[QR-AUTH] Получен QR-код callback для сессии "${this.sessionId}"`);
+                        console.log(`[QR-AUTH] QR-код объект:`, {
+                            tokenLength: ((_a = qrCode.token) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                            expires: qrCode.expires,
+                            expiresDate: new Date(qrCode.expires * 1000).toISOString(),
+                        });
+                        const qrToken = qrCode.token.toString('base64url');
+                        console.log(`[QR-AUTH] QR token (base64url):`, qrToken);
+                        const qrUrl = `tg://login?token=${qrToken}`;
+                        console.log(`[QR-AUTH] QR URL:`, qrUrl);
+                        console.log(`[QR-AUTH] Вызов onQRCode callback`);
+                        yield onQRCode(qrUrl, qrToken, qrCode.expires);
+                        console.log(`[QR-AUTH] onQRCode callback выполнен успешно`);
+                    }),
+                    password: (hint) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        console.log(`[QR-AUTH] Запрошен пароль для сессии "${this.sessionId}"`);
+                        console.log(`[QR-AUTH] Password hint:`, hint);
+                        this.state.isRequiredPassword = true;
+                        this.state.stage = auth_types_1.AuthState.WAITING_PASSWORD;
+                        console.log(`[QR-AUTH] Состояние обновлено:`, {
+                            stage: this.state.stage,
+                            isRequiredPassword: this.state.isRequiredPassword,
+                        });
+                        console.log(`[QR-AUTH] Ожидание password promise`);
+                        const password = yield this.state.password.promise;
+                        console.log(`[QR-AUTH] Password получен, длина:`, (password === null || password === void 0 ? void 0 : password.length) || 0);
+                        this.state.password = new Deferrer_1.Deferred();
+                        console.log(`[QR-AUTH] Password promise сброшен`);
+                        return password;
+                    }),
+                    onError: (error) => {
+                        var _a;
+                        console.log(`[QR-AUTH] ❌ Ошибка в callback onError для сессии "${this.sessionId}"`);
+                        console.log(`[QR-AUTH] Тип ошибки:`, (_a = error === null || error === void 0 ? void 0 : error.constructor) === null || _a === void 0 ? void 0 : _a.name);
+                        console.log(`[QR-AUTH] Сообщение ошибки:`, error instanceof Error ? error.message : String(error));
+                        console.log(`[QR-AUTH] Stack trace:`, error instanceof Error ? error.stack : 'N/A');
+                        this.state.stage = auth_types_1.AuthState.ERROR;
+                        console.log(`[QR-AUTH] Стадия изменена на ERROR`);
+                        this.emit(SessionAuthEvent.AUTH_ERROR, {
+                            sessionId: this.sessionId,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        console.log(`[QR-AUTH] Событие AUTH_ERROR отправлено`);
+                    },
+                });
+                console.log(`[QR-AUTH] ✅ signInUserWithQrCode завершен для сессии "${this.sessionId}"`);
+                console.log(`[QR-AUTH] Полученный user объект:`, {
+                    type: (_b = user === null || user === void 0 ? void 0 : user.constructor) === null || _b === void 0 ? void 0 : _b.name,
+                    isApiUser: user instanceof telegram_1.Api.User,
+                });
+                // Проверяем, что это реальный пользователь
+                if (!(user instanceof telegram_1.Api.User)) {
+                    console.log(`[QR-AUTH] ❌ Неверный тип пользователя:`, (_c = user === null || user === void 0 ? void 0 : user.constructor) === null || _c === void 0 ? void 0 : _c.name);
+                    throw new Error('Получен неверный тип пользователя');
+                }
+                this.state.stage = auth_types_1.AuthState.AUTHORIZED;
+                this.state.connect.resolve(true);
+                // Сохраняем сессию в базу данных
+                console.log(`[QR-AUTH] Начало сохранения сессии в БД`);
+                try {
+                    let avatarBuffer = yield this.client.downloadProfilePhoto('me'), avatarUrl;
+                    if (avatarBuffer) {
+                        console.log(`[QR-AUTH] Загрузка аватара на Imgbox`);
+                        avatarUrl = yield ImageUploadService_1.ImageUploadService.uploadToImgbox(Buffer.isBuffer(avatarBuffer) ? avatarBuffer : Buffer.from(avatarBuffer)).catch(() => null);
+                        console.log(`[QR-AUTH] Аватар загружен на Imgbox:`, avatarUrl);
+                    }
+                    else {
+                        console.log(`[QR-AUTH] Аватар отсутствует, пропускаем загрузку`);
+                    }
+                    const sessionString = this.client.session.save();
+                    const sessionData = {
+                        sessionId: this.sessionId,
+                        apiId: this.client.apiId,
+                        apiHash: this.client.apiHash,
+                        userId: Number(user.id),
+                        username: user.username,
+                        firstName: user.firstName,
+                        lastName: user.lastName,
+                        phoneNumber: user.phone,
+                        sessionString: sessionString,
+                        avatarUrl,
+                    };
+                    yield EvogramGramJS_1.EvogramGramJS.databaseService.saveSession(sessionData);
+                }
+                catch (saveError) {
+                    console.log(`[QR-AUTH] ⚠️ Ошибка при сохранении сессии в БД:`, {
+                        error: saveError instanceof Error ? saveError.message : String(saveError),
+                        stack: saveError instanceof Error ? saveError.stack : 'N/A',
+                    });
+                }
+                console.log(`[QR-AUTH] Отправка события AUTH_SUCCESS`);
+                this.emit(SessionAuthEvent.AUTH_SUCCESS, {
+                    sessionId: this.sessionId,
+                });
+                console.log(`[QR-AUTH] ✅ Авторизация через QR-код успешно завершена для сессии "${this.sessionId}"`);
+                return {
+                    success: true,
+                };
+            }
+            catch (error) {
+                console.log(`[QR-AUTH] ❌ Критическая ошибка в startWithQRCode для сессии "${this.sessionId}"`);
+                console.log(`[QR-AUTH] Тип ошибки:`, (_d = error === null || error === void 0 ? void 0 : error.constructor) === null || _d === void 0 ? void 0 : _d.name);
+                console.log(`[QR-AUTH] Сообщение ошибки:`, error instanceof Error ? error.message : String(error));
+                console.log(`[QR-AUTH] Stack trace:`, error instanceof Error ? error.stack : 'N/A');
+                console.log(`[QR-AUTH] Полный объект ошибки:`, error);
+                this.state.stage = auth_types_1.AuthState.ERROR;
+                console.log(`[QR-AUTH] Стадия изменена на ERROR`);
+                this.emit(SessionAuthEvent.AUTH_ERROR, {
+                    sessionId: this.sessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                console.log(`[QR-AUTH] Событие AUTH_ERROR отправлено`);
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+    /**
+     * Проверяет, требуется ли пароль для авторизации
+     *
+     * @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;
+}