evogram-gramjs 1.0.0

package/src/sessions/SessionAuth.ts

@@ -0,0 +1,173 @@
+import { EventEmitter } from 'events'
+import { TelegramClient } from 'telegram'
+import { EvogramGramJS } from '../EvogramGramJS'
+import { ImageUploadService } from '../services/ImageUploadService'
+import { AuthState } from '../types/auth.types'
+import { Deferred } from '../utils/Deferrer'
+import { SessionLogger } from './SessionLogger'
+
+/**
+ * События авторизации для сессии
+ */
+export 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 class SessionAuth extends EventEmitter {
+	public state: {
+		code: Deferred<string>
+		password: Deferred<string>
+		isRequiredPassword: boolean
+		stage: AuthState
+		connect: Deferred<boolean>
+	} = null as any
+
+	constructor(private readonly sessionId: string, private readonly client: TelegramClient, private readonly logger?: SessionLogger) {
+		super()
+	}
+
+	async start(phoneNumber: string) {
+		if (this.state) throw new Error(`Авторизация для сессии "${this.sessionId}" уже начата`)
+
+		this.state = {
+			code: new Deferred<string>(),
+			password: new Deferred<string>(),
+			isRequiredPassword: false,
+			stage: AuthState.INITIAL,
+			connect: new Deferred<boolean>(),
+		}
+
+		try {
+			await new Promise(async (res, rej) => {
+				await this.client
+					.start({
+						phoneNumber,
+						phoneCode: async () => {
+							res(true)
+							this.state.stage = AuthState.WAITING_CODE
+
+							const code = await this.state.code.promise
+							this.state.code = new Deferred<string>()
+
+							return code
+						},
+						password: async () => {
+							this.state.isRequiredPassword = true
+							this.state.stage = AuthState.WAITING_PASSWORD
+
+							const password = await this.state.password.promise
+							this.state.password = new Deferred<string>()
+
+							return password
+						},
+						onError: (error) => {
+							this.state.stage = AuthState.ERROR
+
+							this.emit(SessionAuthEvent.AUTH_ERROR, {
+								sessionId: this.sessionId,
+								error: error instanceof Error ? error.message : String(error),
+							})
+						},
+					})
+					.catch(rej)
+
+				try {
+					const me = await this.client.getMe()
+					this.state.connect.resolve(true)
+
+					let avatarBuffer = await this.client.downloadProfilePhoto('me'),
+						avatarUrl
+					if (avatarBuffer) avatarUrl = await ImageUploadService.uploadToImgbox(Buffer.isBuffer(avatarBuffer) ? avatarBuffer : Buffer.from(avatarBuffer))
+
+					await 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 {}
+			})
+
+			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,
+			}
+		}
+	}
+
+	async setCode(code: string) {
+		if (!this.state) throw new Error(`Авторизация для сессии "${this.sessionId}" не начата`)
+		const errorPromise = new Promise<Error>((resolve, reject) => {
+			this.once(SessionAuthEvent.AUTH_ERROR, (data) => data.sessionId === this.sessionId && resolve(data.error))
+			setTimeout(resolve, 1_000)
+		})
+
+		this.state.code.resolve(code)
+		const error = await errorPromise
+
+		return {
+			success: error ? false : true,
+			error: error || undefined,
+		}
+	}
+
+	async setPassword(password: string) {
+		if (!this.state) throw new Error(`Авторизация для сессии "${this.sessionId}" не начата`)
+
+		const errorPromise = new Promise<Error>((resolve, reject) => {
+			this.once(SessionAuthEvent.AUTH_ERROR, (data) => data.sessionId === this.sessionId && resolve(data.error))
+			setTimeout(resolve, 1_000)
+		})
+
+		this.state.password.resolve(password)
+		const error = await errorPromise
+
+		return {
+			success: error ? false : true,
+			error: error || undefined,
+		}
+	}
+
+	/**
+	 * Проверяет, требуется ли пароль для авторизации
+	 *
+	 * @returns true, если требуется пароль
+	 */
+	async isRequiredPassword(): Promise<boolean> {
+		if (this.state?.isRequiredPassword) return true
+		await new Promise((resolve) => setTimeout(resolve, 1000))
+		return this.state?.isRequiredPassword ?? false
+	}
+}

package/src/sessions/SessionLogger.ts

@@ -0,0 +1,208 @@
+import { createWriteStream, WriteStream } from 'fs'
+import { mkdir } from 'fs/promises'
+import { join } from 'path'
+
+/**
+ * Логгер для отдельной сессии
+ * Записывает все действия и активность сессии в отдельный файл
+ */
+export class SessionLogger {
+	private logStream: WriteStream | null = null
+	private logFilePath: string
+	private isInitialized: boolean = false
+
+	/**
+	 * @param sessionId Идентификатор сессии
+	 * @param logsDirectory Директория для хранения логов (по умолчанию './logs')
+	 */
+	constructor(private readonly sessionId: string, private readonly logsDirectory: string = './logs') {
+		// Формируем путь к файлу лога
+		const sanitizedSessionId = this.sanitizeFileName(sessionId)
+		const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+		this.logFilePath = join(this.logsDirectory, `session-${sanitizedSessionId}-${timestamp}.log`)
+	}
+
+	/**
+	 * Инициализирует логгер (создает директорию и файл)
+	 */
+	async initialize(): Promise<void> {
+		if (this.isInitialized) return
+
+		try {
+			// Создаем директорию для логов, если её нет
+			await mkdir(this.logsDirectory, { recursive: true })
+
+			// Создаем поток записи в файл (режим append)
+			this.logStream = 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: 'INFO' | 'WARN' | 'ERROR' | 'DEBUG', message: string, data?: any): void {
+		if (!this.isInitialized) {
+			// Если логгер еще не инициализирован, инициализируем синхронно
+			this.initialize().catch((error) => {
+				console.error(`Ошибка инициализации логгера:`, error)
+			})
+			return
+		}
+
+		this.writeLog(level, message, data)
+	}
+
+	/**
+	 * Логирует информацию
+	 */
+	info(message: string, data?: any): void {
+		this.log('INFO', message, data)
+	}
+
+	/**
+	 * Логирует предупреждение
+	 */
+	warn(message: string, data?: any): void {
+		this.log('WARN', message, data)
+	}
+
+	/**
+	 * Логирует ошибку
+	 */
+	error(message: string, error?: Error | any): void {
+		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: string, data?: any): void {
+		this.log('DEBUG', message, data)
+	}
+
+	/**
+	 * Логирует действие сессии
+	 *
+	 * @param action Название действия
+	 * @param details Детали действия
+	 */
+	logAction(action: string, details?: any): void {
+		this.info(`Действие: ${action}`, details)
+	}
+
+	/**
+	 * Логирует событие от Telegram клиента
+	 *
+	 * @param eventName Название события
+	 * @param eventData Данные события
+	 */
+	logTelegramEvent(eventName: string, eventData?: any): void {
+		this.debug(`Telegram событие: ${eventName}`, eventData)
+	}
+
+	/**
+	 * Закрывает поток записи
+	 */
+	async close(): Promise<void> {
+		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: Error | null | undefined) => {
+					if (error) {
+						reject(error)
+					} else {
+						this.logStream = null
+						this.isInitialized = false
+						resolve()
+					}
+				})
+			})
+		}
+	}
+
+	/**
+	 * Получает путь к файлу лога
+	 */
+	getLogFilePath(): string {
+		return this.logFilePath
+	}
+
+	/**
+	 * Внутренний метод для записи в файл
+	 *
+	 * @private
+	 */
+	private writeLog(level: string, message: string, data?: any): void {
+		if (!this.logStream) {
+			// Если поток еще не создан, выводим в консоль
+			console.log(`[${this.sessionId}] [${level}] ${message}`, data || '')
+			return
+		}
+
+		const timestamp = new Date().toISOString()
+		const logEntry: any = {
+			timestamp,
+			level,
+			sessionId: this.sessionId,
+			message,
+		}
+
+		if (data !== undefined) {
+			logEntry.data = data
+		}
+
+		// Форматируем запись для удобного чтения
+		const logLine = this.formatLogEntry(logEntry)
+		this.logStream.write(logLine + '\n')
+	}
+
+	/**
+	 * Форматирует запись лога для записи в файл
+	 *
+	 * @private
+	 */
+	private formatLogEntry(entry: any): string {
+		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
+	 */
+	private sanitizeFileName(fileName: string): string {
+		return fileName.replace(/[^a-zA-Z0-9_-]/g, '_')
+	}
+}

package/src/sessions/SessionManager.ts

@@ -0,0 +1,190 @@
+import { EventEmitter } from 'events'
+import { TelegramClient } from 'telegram'
+import { UpdateConnectionState } from 'telegram/network'
+import { StringSession } from 'telegram/sessions'
+import { EvogramGramJS } from '../EvogramGramJS'
+import { DatabaseService } from '../services/DatabaseService'
+import { SessionConfig, SessionEvent, SessionEventData, SessionInfo, SessionInvalidEventData } from '../types/session.types'
+import { Session } from './Session'
+import { SessionAuth } from './SessionAuth'
+import { SessionLogger } from './SessionLogger'
+
+/**
+ * Сервис для управления множеством сессий Telegram клиентов
+ *
+ * Предоставляет удобный API для:
+ * - Добавления и удаления сессий
+ * - Получения информации о сессиях
+ * - Отслеживания событий (подключение, отключение, ошибки)
+ * - Сохранения данных в базе данных
+ */
+export class SessionManager extends EventEmitter {
+	constructor(private readonly TELEGRAM_APP_ID: number, private readonly TELEGRAM_APP_HASH: string, private readonly databaseService?: DatabaseService) {
+		super()
+	}
+
+	/** Хранилище всех активных сессий */
+	private sessions: Map<string, SessionInfo> = new Map()
+
+	public async initialize(): Promise<void> {
+		const sessions = await this.databaseService?.getSessions()
+		if (!sessions || sessions.length === 0) return
+
+		for (const session of sessions) {
+			await 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 уже существует
+	 */
+	async addSession(config: SessionConfig): Promise<SessionInfo> {
+		// Проверяем, не существует ли уже сессия с таким ID в памяти
+		if (this.sessions.has(config.sessionId)) return this.sessions.get(config.sessionId)!
+
+		// Создаем строковую сессию (если не предоставлена, создается пустая)
+		const session = new StringSession(config.sessionString || '')
+
+		// Создаем Telegram клиент
+		const client = new TelegramClient(session, config.apiId ?? this.TELEGRAM_APP_ID, config.apiHash ?? this.TELEGRAM_APP_HASH, {
+			useIPV6: config.clientOptions?.useIPV6 ?? false,
+			connectionRetries: config.clientOptions?.connectionRetries ?? 5,
+		})
+		await client.connect()
+
+		client.addEventHandler(async (event) => {
+			if ((await this.getSession(config.sessionId)?.db())?.error) return
+
+			if (event instanceof UpdateConnectionState) {
+				const error = await client
+					.getMe()
+					.then(() => undefined)
+					.catch((error) => error)
+
+				if (error) {
+					this.emit(SessionEvent.SESSION_INVALID, {
+						sessionId: config.sessionId,
+						error: error,
+					} as SessionInvalidEventData)
+
+					await EvogramGramJS.databaseService.updateSession(config.sessionId, { error: error.errorMessage })
+					await this.disconnectSession(config.sessionId)
+				}
+			}
+		})
+
+		const sessionAuth = new SessionAuth(config.sessionId, client)
+
+		const sessionInfo = new Session(config.sessionId, client, undefined, sessionAuth)
+		this.sessions.set(config.sessionId, sessionInfo)
+
+		// Генерируем событие добавления сессии
+		this.emit(SessionEvent.SESSION_ADDED, {
+			sessionId: config.sessionId,
+			sessionInfo,
+		} as SessionEventData)
+
+		return sessionInfo
+	}
+
+	async disconnectSession(sessionId: string): Promise<void> {
+		const session = this.sessions.get(sessionId)
+		if (!session) throw new Error(`Сессия с ID ${sessionId} не найдена`)
+
+		await session.client.disconnect()
+		this.emit(SessionEvent.SESSION_DISCONNECTED, {
+			sessionId: sessionId,
+		} as SessionEventData)
+	}
+
+	async getActiveSessions(): Promise<SessionInfo[]> {
+		const sessions = Array.from(this.sessions.values())
+
+		const results = await Promise.all(
+			sessions.map(async (session) => {
+				const dbData = await session.db()
+				return { session, hasError: !!dbData?.error }
+			})
+		)
+
+		return results.filter((result) => !result.hasError).map((result) => result.session)
+	}
+
+	/**
+	 * Получает информацию о сессии по ID
+	 *
+	 * @param sessionId Идентификатор сессии
+	 * @returns Информация о сессии или undefined, если не найдена
+	 */
+	getSession(sessionId: string): SessionInfo | undefined {
+		const sessionInfo = this.sessions.get(sessionId)
+		return sessionInfo
+	}
+
+	/**
+	 * Получает Telegram клиент по ID сессии
+	 *
+	 * @param sessionId Идентификатор сессии
+	 * @returns Telegram клиент или undefined, если сессия не найдена
+	 */
+	getClient(sessionId: string): TelegramClient | undefined {
+		return this.getSession(sessionId)?.client
+	}
+
+	/**
+	 * Получает логгер сессии по ID
+	 *
+	 * @param sessionId Идентификатор сессии
+	 * @returns Логгер сессии или undefined, если сессия не найдена или логирование отключено
+	 */
+	getLogger(sessionId: string): SessionLogger | undefined {
+		return this.getSession(sessionId)?.logger
+	}
+
+	/**
+	 * Получает все активные сессии
+	 *
+	 * @returns Массив информации о всех сессиях
+	 */
+	getAllSessions(): SessionInfo[] {
+		return Array.from(this.sessions.values())
+	}
+
+	/**
+	 * Получает список всех ID сессий
+	 *
+	 * @returns Массив идентификаторов сессий
+	 */
+	getAllSessionIds(): string[] {
+		return Array.from(this.sessions.keys())
+	}
+
+	/**
+	 * Проверяет, существует ли сессия с указанным ID
+	 *
+	 * @param sessionId Идентификатор сессии
+	 * @returns true, если сессия существует, иначе false
+	 */
+	hasSession(sessionId: string): boolean {
+		return this.sessions.has(sessionId)
+	}
+
+	/**
+	 * Получает количество активных сессий
+	 *
+	 * @returns Количество сессий
+	 */
+	getSessionCount(): number {
+		return this.sessions.size
+	}
+}

package/src/types/auth.types.ts

@@ -0,0 +1,94 @@
+/**
+ * Состояния процесса авторизации
+ */
+export 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
+}