evogram-gramjs 1.0.0

package/lib/sessions/SessionManager.js

@@ -0,0 +1,184 @@
+"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;
+                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;
+                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());
+    }
+    /**
+     * Получает список всех 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/types/auth.types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Состояния процесса авторизации
+ */
+export declare enum AuthState {
+    /** Начальное состояние - не авторизован */
+    INITIAL = "initial",
+    /** Ожидание кода подтверждения */
+    WAITING_CODE = "waiting_code",
+    /** Ожидание пароля (2FA) */
+    WAITING_PASSWORD = "waiting_password",
+    /** Авторизация завершена */
+    AUTHORIZED = "authorized",
+    /** Ошибка авторизации */
+    ERROR = "error"
+}
+/**
+ * Информация о процессе авторизации
+ */
+export interface AuthInfo {
+    /** Идентификатор сессии */
+    sessionId: string;
+    /** Текущее состояние авторизации */
+    state: AuthState;
+    /** Номер телефона (если указан) */
+    phoneNumber?: string;
+    /** Требуется ли пароль (2FA) */
+    isRequiredPassword: boolean;
+    /** Код подтверждения (если ожидается) */
+    code?: string;
+    /** Пароль (2FA) (если ожидается) */
+    password?: string;
+    /** Хеш кода подтверждения */
+    phoneCodeHash?: string;
+    /** Сообщение об ошибке (если есть) */
+    error?: string;
+    /** Время начала авторизации */
+    startedAt: Date;
+    /** Время последнего обновления */
+    updatedAt: Date;
+    /** Промисы для ожидания кода и пароля */
+    _codeResolver?: (code: string) => void;
+    _codeRejecter?: (error: Error) => void;
+    _passwordResolver?: (password: string) => void;
+    _passwordRejecter?: (error: Error) => void;
+    /** Промис для отслеживания начальной ошибки (до запроса кода) */
+    _initialErrorRejecter?: (error: Error) => void;
+    /** Resolver для промиса, когда код был запрошен (успешное начало) */
+    _codeRequestedResolver?: () => void;
+    /** Флаг, что код был запрошен (для различения начальной ошибки от ошибки после запроса кода) */
+    _codeRequested?: boolean;
+    /** Флаг, что была ошибка неверного кода (для отслеживания повторной попытки) */
+    _hasCodeError?: boolean;
+}
+/**
+ * Результат отправки кода
+ */
+export interface SendCodeResult {
+    /** Успешно ли отправлен код */
+    success: boolean;
+    /** Требуется ли пароль (2FA) */
+    isRequiredPassword: boolean;
+    /** Сообщение об ошибке (если есть) */
+    error?: string;
+    /** Тип отправки кода (sms, call, etc.) */
+    phoneCodeHash?: string;
+}
+/**
+ * Результат ввода кода
+ */
+export interface SignInResult {
+    /** Успешно ли авторизован */
+    success: boolean;
+    /** Требуется ли пароль (2FA) */
+    isRequiredPassword: boolean;
+    /** Сообщение об ошибке (если есть) */
+    error?: string;
+    /** Строка сессии (если авторизация успешна) */
+    sessionString?: string;
+}
+/**
+ * Результат ввода пароля
+ */
+export interface SignInWithPasswordResult {
+    /** Успешно ли авторизован */
+    success: boolean;
+    /** Сообщение об ошибке (если есть) */
+    error?: string;
+    /** Строка сессии (если авторизация успешна) */
+    sessionString?: string;
+}

package/lib/types/auth.types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthState = void 0;
+/**
+ * Состояния процесса авторизации
+ */
+var AuthState;
+(function (AuthState) {
+    /** Начальное состояние - не авторизован */
+    AuthState["INITIAL"] = "initial";
+    /** Ожидание кода подтверждения */
+    AuthState["WAITING_CODE"] = "waiting_code";
+    /** Ожидание пароля (2FA) */
+    AuthState["WAITING_PASSWORD"] = "waiting_password";
+    /** Авторизация завершена */
+    AuthState["AUTHORIZED"] = "authorized";
+    /** Ошибка авторизации */
+    AuthState["ERROR"] = "error";
+})(AuthState || (exports.AuthState = AuthState = {}));

package/lib/types/session.types.d.ts

@@ -0,0 +1,87 @@
+import { Session } from '../sessions/Session';
+/**
+ * Конфигурация для создания новой сессии
+ */
+export interface SessionConfig {
+    /** Уникальный идентификатор сессии */
+    sessionId: string;
+    /** API ID из Telegram */
+    apiId?: number;
+    /** API Hash из Telegram */
+    apiHash?: string;
+    /** Строка сессии (если уже существует) */
+    sessionString?: string;
+    /** Дополнительные опции для клиента */
+    clientOptions?: {
+        /** Использовать IPv6 */
+        useIPV6?: boolean;
+        /** Таймаут подключения */
+        connectionRetries?: number;
+        /** Максимальное количество попыток переподключения */
+        maxRetries?: number;
+    };
+    /** Настройки логирования */
+    logging?: {
+        /** Включить логирование (по умолчанию true) */
+        enabled?: boolean;
+        /** Директория для хранения логов (по умолчанию './logs') */
+        logsDirectory?: string;
+    };
+}
+/**
+ * Информация о сессии
+ * Использует класс Session для представления сессии
+ */
+export type SessionInfo = Session;
+/**
+ * События, которые может генерировать менеджер сессий
+ */
+export declare enum SessionEvent {
+    /** Сессия была добавлена */
+    SESSION_ADDED = "session:added",
+    /** Сессия была удалена */
+    SESSION_REMOVED = "session:removed",
+    /** Сессия подключилась */
+    SESSION_CONNECTED = "session:connected",
+    /** Сессия отключилась */
+    SESSION_DISCONNECTED = "session:disconnected",
+    /** Произошла ошибка в сессии */
+    SESSION_ERROR = "session:error",
+    /** Сессия стала недействительной */
+    SESSION_INVALID = "session:invalid"
+}
+/**
+ * Данные события добавления/удаления сессии
+ */
+export interface SessionEventData {
+    sessionId: string;
+    sessionInfo?: Session;
+}
+/**
+ * Данные события подключения/отключения
+ */
+export interface SessionConnectionEventData {
+    sessionId: string;
+    isConnected: boolean;
+}
+/**
+ * Данные события ошибки
+ */
+export interface SessionErrorEventData {
+    sessionId: string;
+    error: Error;
+}
+/**
+ * Данные события удаления сессии
+ */
+export interface SessionRemovedEventData {
+    sessionId: string;
+    error: Error;
+}
+/**
+ * Данные события недействительности сессии
+ */
+export interface SessionInvalidEventData {
+    sessionId: string;
+    error: Error;
+}

package/lib/types/session.types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionEvent = void 0;
+/**
+ * События, которые может генерировать менеджер сессий
+ */
+var SessionEvent;
+(function (SessionEvent) {
+    /** Сессия была добавлена */
+    SessionEvent["SESSION_ADDED"] = "session:added";
+    /** Сессия была удалена */
+    SessionEvent["SESSION_REMOVED"] = "session:removed";
+    /** Сессия подключилась */
+    SessionEvent["SESSION_CONNECTED"] = "session:connected";
+    /** Сессия отключилась */
+    SessionEvent["SESSION_DISCONNECTED"] = "session:disconnected";
+    /** Произошла ошибка в сессии */
+    SessionEvent["SESSION_ERROR"] = "session:error";
+    /** Сессия стала недействительной */
+    SessionEvent["SESSION_INVALID"] = "session:invalid";
+})(SessionEvent || (exports.SessionEvent = SessionEvent = {}));

package/lib/utils/Deferrer.d.ts

@@ -0,0 +1,6 @@
+export declare class Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    constructor();
+}

package/lib/utils/Deferrer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deferred = void 0;
+class Deferred {
+    constructor() {
+        this.resolve = () => { };
+        this.reject = () => { };
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+exports.Deferred = Deferred;

package/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "evogram-gramjs",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "evogram-gramjs",
+	"version": "1.0.0",
+	"main": "./lib/index.js",
+	"license": "MIT",
+	"dependencies": {
+		"axios": "^1.9.0",
+		"chalk": "^5.4.1",
+		"lodash": "^4.17.21",
+		"reflect-metadata": "^0.2.2",
+		"sqlite": "^5.1.1",
+		"typeorm": "^0.3.20"
+	},
+	"peerDependencies": {
+		"evogram": "^2.10.4",
+		"telegram": "^2.26.22"
+	},
+	"devDependencies": {
+		"@types/lodash": "^4.17.21",
+		"@types/node": "^24.3.0",
+		"evogram": "^2.10.4",
+		"telegram": "^2.26.22"
+	},
+	"optionalDependencies": {
+		"better-sqlite3": "^11.3.0"
+	}
+}

package/src/EvogramGramJS.ts

@@ -0,0 +1,98 @@
+import { DatabaseConfig } from './config/database.config'
+import { DatabaseService } from './services/DatabaseService'
+import { SessionManager } from './sessions/SessionManager'
+
+/**
+ * Главный статический класс для работы с EvogramGramJS
+ * Управляет сессиями Telegram и базой данных
+ */
+export class EvogramGramJS {
+	private static _sessionManager: SessionManager | null = null
+	private static _databaseService: DatabaseService | null = null
+	private static _telegramAppId: number | null = null
+	private static _telegramAppHash: string | null = null
+
+	/**
+	 * Инициализирует EvogramGramJS
+	 *
+	 * @param telegramAppId API ID из Telegram
+	 * @param telegramAppHash API Hash из Telegram
+	 * @param databaseConfig Конфигурация базы данных (опционально)
+	 */
+	static initialize(telegramAppId: number, telegramAppHash: string, databaseConfig?: DatabaseConfig): void {
+		this._telegramAppId = telegramAppId
+		this._telegramAppHash = telegramAppHash
+
+		// Инициализируем сервис базы данных
+		this._databaseService = new DatabaseService()
+
+		// Инициализируем менеджер сессий с поддержкой БД
+		this._sessionManager = new SessionManager(telegramAppId, telegramAppHash, this._databaseService)
+
+		// Инициализируем базу данных асинхронно
+		if (databaseConfig) {
+			this._databaseService
+				.initialize(databaseConfig)
+				.then(async () => {
+					// Автоматически загружаем сессии из базы данных после инициализации
+					if (this._sessionManager) await this._sessionManager.initialize()
+				})
+				.catch((error) => {
+					console.error('Ошибка инициализации базы данных:', error)
+				})
+		}
+	}
+
+	/**
+	 * Получает менеджер сессий
+	 *
+	 * @returns SessionManager
+	 * @throws Error если EvogramGramJS не инициализирован
+	 */
+	static get sessionManager(): SessionManager {
+		if (!this._sessionManager) throw new Error('EvogramGramJS не инициализирован. Вызовите EvogramGramJS.initialize() сначала.')
+
+		return this._sessionManager
+	}
+
+	/**
+	 * Получает сервис базы данных
+	 *
+	 * @returns DatabaseService
+	 * @throws Error если EvogramGramJS не инициализирован
+	 */
+	static get databaseService(): DatabaseService {
+		if (!this._databaseService) throw new Error('EvogramGramJS не инициализирован. Вызовите EvogramGramJS.initialize() сначала.')
+
+		return this._databaseService
+	}
+
+	/**
+	 * Инициализирует базу данных
+	 *
+	 * @param config Конфигурация базы данных
+	 */
+	static async initializeDatabase(config: DatabaseConfig): Promise<void> {
+		if (!this._databaseService) throw new Error('EvogramGramJS не инициализирован. Вызовите EvogramGramJS.initialize() сначала.')
+		await this._databaseService.initialize(config)
+
+		// Автоматически загружаем сессии из базы данных после инициализации
+		if (this._sessionManager) await this._sessionManager.initialize()
+	}
+
+	/**
+	 * Закрывает подключение к базе данных
+	 */
+	static async closeDatabase(): Promise<void> {
+		if (this._databaseService) await this._databaseService.close()
+	}
+
+	/**
+	 * Проверяет, инициализирован ли EvogramGramJS
+	 *
+	 * @returns true, если инициализирован
+	 */
+	static isInitialized(): boolean {
+		return this._sessionManager !== null && this._databaseService !== null
+	}
+}

package/src/commands/Accounts.command.ts

@@ -0,0 +1,84 @@
+import { Command, CommandArgument, CommandContext, CommandD, CommandUpdate, InlineQueryContext, MessageContext } from 'evogram'
+import { EvogramGramJS } from '../EvogramGramJS'
+import { AddAccountCommand } from './AddAccount.command'
+
+@CommandD({ name: 'accounts' })
+export class AccountsCommand extends Command {
+	public async execute(context: CommandContext, @CommandArgument('sessionId?') sessionId?: string) {
+		if (!sessionId)
+			//@ts-ignore
+			return context[context.callbackQuery ? 'edit' : 'send']?.({
+				// prettier-ignore
+				text: 
+					'<blockquote><b>📊 Список аккаунтов</b></blockquote>\n\n' +
+					
+					'<i>Панель управлениями Вашими аккаунтами</i>',
+				parse_mode: 'HTML',
+				reply_markup: {
+					inline_keyboard: [
+						[
+							{ text: 'Добавить', command: AddAccountCommand, payload: { phone: null, session: null, code: null, password: null } },
+							{ text: 'Список', command: AccountsCommand, switch_inline_query_current_chat: ' ' },
+						],
+					],
+				},
+			})
+
+		const session = EvogramGramJS.sessionManager.getSession(sessionId)
+		const db = await session?.db()
+		const me = await session?.client
+			.getMe()
+			.then((x) => x)
+			.catch(() => null)
+
+		//@ts-ignore
+		return context[context.callbackQuery ? 'edit' : 'send']?.({
+			// prettier-ignore
+			text: 
+				`<blockquote><b>👤 Аккаунт <a href="tg://user?id=${db?.userId}">${db?.firstName}</a></b></blockquote>\n\n` +
+
+				`<i>— ID: ${db?.userId}</i>\n` +
+				`<i>— Phone: ${db?.phoneNumber}</i>\n\n` +
+
+				`<b>${me ? '✅ Активен и доступен к работе' : db?.error ? `❌ ${db?.error}` : '❌ Неавторизованный'}</b>`,
+			parse_mode: 'HTML',
+		})
+	}
+
+	@CommandUpdate('message')
+	public async handleMessage(context: CommandContext, message: MessageContext) {
+		if (!message.viaBot) return
+
+		message.delete().catch(() => null)
+		return context.redirect(AccountsCommand, { sessionId: message.text })
+	}
+
+	public async inlineExecute(context: InlineQueryContext) {
+		const accounts = EvogramGramJS.sessionManager.getAllSessions()
+
+		context.answer(
+			await Promise.all(
+				accounts.map(async (x) => {
+					const db = await x.db()
+
+					return {
+						type: 'article',
+						id: x.sessionId,
+						title: db ? `${db?.firstName} ${db?.lastName || ''}` : 'Безымянный',
+						description: db?.error ? `❌ ${db?.error}` : db ? '✅ Аккаунт активен' : '❌ Неавторизованный',
+						thumbnail_url: db?.avatarUrl || undefined,
+						input_message_content: {
+							message_text: x.sessionId,
+						},
+					}
+				})
+			),
+			{
+				switch_pm_text: accounts.length > 0 ? `Добавлено ${accounts.length} аккаунтов` : 'Нет доступных аккаунтов',
+				switch_pm_parameter: 'accounts',
+				cache_time: 0,
+				is_personal: true,
+			}
+		)
+	}
+}