webmaxsocket 1.0.0 → 1.1.0

package/lib/client.js

@@ -1,13 +1,35 @@
+const fs = require('fs');
+const path = require('path');
 const WebSocket = require('ws');
 const EventEmitter = require('events');
 const { v4: uuidv4 } = require('uuid');
 const qrcode = require('qrcode-terminal');
 const SessionManager = require('./session');
+const { MaxSocketTransport } = require('./socketTransport');
 const { Message, ChatAction, User } = require('./entities');
 const { EventTypes, ChatActions } = require('./constants');
 const { Opcode, DeviceType, getOpcodeName } = require('./opcodes');
 const { UserAgentPayload } = require('./userAgent');
 
+/**
+ * Загружает конфиг: { token, agent }
+ */
+function loadSessionConfig(configPath) {
+  let resolved;
+  if (path.isAbsolute(configPath)) {
+    resolved = configPath;
+  } else if (!/[\\/]/.test(configPath) && !configPath.endsWith('.json')) {
+    resolved = path.join(process.cwd(), 'config', `${configPath}.json`);
+  } else {
+    resolved = path.join(process.cwd(), configPath);
+  }
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Конфиг не найден: ${resolved}`);
+  }
+  const data = fs.readFileSync(resolved, 'utf8');
+  return JSON.parse(data);
+}
+
 /**
  * Основной клиент для работы с API Max
  */
@@ -18,20 +40,53 @@ class WebMaxClient extends EventEmitter {
     this.phone = options.phone || null;
     this.sessionName = options.name || options.session || 'default';
     this.apiUrl = options.apiUrl || 'wss://ws-api.oneme.ru/websocket';
+    
+    // Загрузка из config — token, ua (agent), device_type
+    let token = options.token || null;
+    let agent = options.ua || options.agent || options.headerUserAgent || null;
+    let configObj = {};
+    const configPath = options.configPath || options.config;
+    if (configPath) {
+      configObj = loadSessionConfig(configPath);
+      token = token || configObj.token || null;
+      agent = agent || configObj.agent || configObj.ua || configObj.headerUserAgent || null;
+    }
+    
+    this._providedToken = token;
+    this._saveTokenToSession = options.saveToken !== false;
     this.origin = 'https://web.max.ru';
     this.session = new SessionManager(this.sessionName);
     
-    // UserAgent
-    this.userAgent = options.userAgent || new UserAgentPayload({
-      appVersion: options.appVersion || '25.12.14'
-    });
+    const deviceTypeMap = { 1: 'WEB', 2: 'IOS', 3: 'ANDROID' };
+    const rawDeviceType = options.deviceType ?? configObj.device_type ?? configObj.deviceType ?? this.session.get('deviceType');
+    const deviceType = deviceTypeMap[rawDeviceType] || rawDeviceType || 'WEB';
+    const uaString = agent || configObj.headerUserAgent || configObj.ua || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36';
+    const webDefaults = {
+      deviceType: deviceType,
+      locale: configObj.locale || 'ru',
+      deviceLocale: configObj.deviceLocale || configObj.locale || 'ru',
+      osVersion: configObj.osVersion || (deviceType === 'IOS' ? '18.6.2' : deviceType === 'ANDROID' ? '14' : 'Linux'),
+      deviceName: configObj.deviceName || (deviceType === 'IOS' ? 'Safari' : deviceType === 'ANDROID' ? 'Chrome' : 'Chrome'),
+      headerUserAgent: uaString,
+      appVersion: configObj.appVersion || '25.10.5',
+      screen: configObj.screen || (deviceType === 'IOS' ? '390x844 3.0x' : deviceType === 'ANDROID' ? '360x780 3.0x' : '1080x1920 1.0x'),
+      timezone: configObj.timezone || 'Europe/Moscow',
+      buildNumber: configObj.buildNumber,
+      clientSessionId: configObj.clientSessionId || this.session.get('clientSessionId'),
+      release: configObj.release
+    };
+    this._handshakeUserAgent = new UserAgentPayload(webDefaults);
+    this.userAgent = this._handshakeUserAgent;
     
-    // Device ID
     this.deviceId = options.deviceId || this.session.get('deviceId') || uuidv4();
     if (!this.session.get('deviceId')) {
       this.session.set('deviceId', this.deviceId);
     }
     
+    // Определяем тип транспорта: Socket для IOS/ANDROID, WebSocket для WEB
+    this._useSocketTransport = (deviceType === 'IOS' || deviceType === 'ANDROID');
+    this._socketTransport = null;
+    
     this.ws = null;
     this.me = null;
     this.isConnected = false;
@@ -55,6 +110,7 @@ class WebMaxClient extends EventEmitter {
 
     this.messageQueue = [];
     this.pendingRequests = new Map();
+    this.debug = options.debug || process.env.DEBUG === '1';
   }
 
   /**
@@ -135,22 +191,35 @@ class WebMaxClient extends EventEmitter {
     try {
       console.log('🚀 Запуск WebMax клиента...');
       
-      // Подключаемся к WebSocket
+      // Подключаемся к WebSocket или Socket
       await this.connect();
       
-      // Проверяем наличие сохраненного токена
-      const savedToken = this.session.get('token');
+      // Приоритет: 1) переданный токен, 2) сохранённая сессия, 3) QR-авторизация
+      const tokenToUse = this._providedToken || this.session.get('token');
       
-      if (savedToken) {
-        console.log('✅ Найдена сохраненная сессия');
-        this._token = savedToken;
+      if (tokenToUse) {
+        if (this._providedToken) {
+          console.log('✅ Вход по токену (token auth)');
+          if (this._saveTokenToSession) {
+            this.session.set('token', this._providedToken);
+            this.session.set('deviceId', this.deviceId);
+          }
+        } else {
+          console.log('✅ Найдена сохраненная сессия');
+        }
+        this._token = tokenToUse;
         
         try {
           await this.sync();
           this.isAuthorized = true;
         } catch (error) {
-          console.log('⚠️ Сессия истекла, требуется повторная авторизация');
+          const wasTokenAuth = !!this._providedToken;
           this.session.clear();
+          this._providedToken = null;
+          if (wasTokenAuth) {
+            throw new Error(`Токен недействителен или сессия истекла. Обновите токен в config. (${error.message})`);
+          }
+          console.log('⚠️ Сессия истекла, требуется повторная авторизация');
           await this.authorize();
         }
       } else {
@@ -288,12 +357,25 @@ class WebMaxClient extends EventEmitter {
         throw new Error('Токен не получен из ответа');
       }
       
+      // Сохраняем токен и все данные сессии для TCP подключения
       this.session.set('token', token);
       this.session.set('deviceId', this.deviceId);
+      this.session.set('clientSessionId', this.userAgent.clientSessionId);
+      this.session.set('deviceType', 'IOS'); // Переключаемся на IOS для TCP при следующем запуске
+      this.session.set('headerUserAgent', this.userAgent.headerUserAgent);
+      this.session.set('appVersion', this.userAgent.appVersion);
+      this.session.set('osVersion', this.userAgent.osVersion);
+      this.session.set('deviceName', this.userAgent.deviceName);
+      this.session.set('screen', this.userAgent.screen);
+      this.session.set('timezone', this.userAgent.timezone);
+      this.session.set('locale', this.userAgent.locale);
+      this.session.set('buildNumber', this.userAgent.buildNumber);
+      
       this.isAuthorized = true;
       this._token = token;
       
       console.log('✅ Авторизация через QR-код успешна!');
+      console.log('💡 При следующем запуске будет использоваться TCP Socket транспорт');
       
       // Выполняем sync
       await this.sync();
@@ -305,11 +387,105 @@ class WebMaxClient extends EventEmitter {
   }
 
   /**
-   * Авторизация пользователя через QR-код
+   * Авторизация по номеру телефона через SMS (для IOS/ANDROID)
    */
-  async authorize() {
-    console.log('🔐 Авторизация через QR-код');
-    await this.authorizeByQR();
+  async authorizeBySMS(phone) {
+    if (!this._useSocketTransport) {
+      throw new Error('SMS авторизация доступна только для IOS/ANDROID (используйте deviceType: "IOS" или "ANDROID")');
+    }
+
+    try {
+      console.log('📱 Авторизация по номеру телефона...');
+      
+      // Нормализация номера телефона
+      let cleanPhone = phone.replace(/\D/g, '');
+      if (cleanPhone.startsWith('8') && cleanPhone.length === 11) {
+        cleanPhone = '7' + cleanPhone.slice(1);
+      } else if (cleanPhone.startsWith('9') && cleanPhone.length === 10) {
+        cleanPhone = '7' + cleanPhone;
+      }
+      const normalizedPhone = '+' + cleanPhone;
+
+      console.log(`📤 Запрос кода на номер: ${normalizedPhone}`);
+      
+      if (!this._socketTransport) {
+        throw new Error('Socket транспорт не инициализирован');
+      }
+
+      // Запрос кода
+      const tempToken = await this._socketTransport.requestCode(normalizedPhone);
+      
+      if (!tempToken) {
+        throw new Error('Не получен временный токен');
+      }
+
+      console.log('✅ Код отправлен! Ожидаем ввода кода...');
+      
+      return {
+        tempToken,
+        phone: normalizedPhone,
+        sendCode: async (code) => {
+          console.log('🔐 Проверка кода...');
+          
+          const authResponse = await this._socketTransport.sendCode(tempToken, code);
+          
+          if (authResponse?.passwordChallenge) {
+            throw new Error('2FA не поддерживается');
+          }
+
+          const token = authResponse?.tokenAttrs?.LOGIN?.token;
+          
+          if (!token) {
+            throw new Error('Токен не получен из ответа');
+          }
+
+          // Сохраняем сессию
+          this.session.set('token', token);
+          this.session.set('deviceId', this.deviceId);
+          this.session.set('clientSessionId', this.userAgent.clientSessionId);
+          this.session.set('deviceType', this.userAgent.deviceType);
+          this.session.set('headerUserAgent', this.userAgent.headerUserAgent);
+          this.session.set('appVersion', this.userAgent.appVersion);
+          this.session.set('osVersion', this.userAgent.osVersion);
+          this.session.set('deviceName', this.userAgent.deviceName);
+          this.session.set('screen', this.userAgent.screen);
+          this.session.set('timezone', this.userAgent.timezone);
+          this.session.set('locale', this.userAgent.locale);
+          this.session.set('buildNumber', this.userAgent.buildNumber);
+          
+          this.isAuthorized = true;
+          this._token = token;
+          
+          console.log('✅ Авторизация по SMS успешна!');
+          
+          // Выполняем sync
+          await this.sync();
+          
+          return token;
+        }
+      };
+      
+    } catch (error) {
+      console.error('Ошибка SMS авторизации:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Авторизация пользователя (QR-код для WEB, SMS для IOS/ANDROID)
+   */
+  async authorize(phone = null) {
+    if (this._useSocketTransport && phone) {
+      // SMS авторизация для IOS/ANDROID
+      console.log('🔐 Авторизация через SMS');
+      return await this.authorizeBySMS(phone);
+    } else if (this._useSocketTransport && !phone) {
+      throw new Error('Для IOS/ANDROID требуется номер телефона. Используйте: authorize("+79001234567")');
+    } else {
+      // QR авторизация для WEB
+      console.log('🔐 Авторизация через QR-код');
+      await this.authorizeByQR();
+    }
   }
 
 
@@ -332,14 +508,16 @@ class WebMaxClient extends EventEmitter {
       contactsSync: 0,
       presenceSync: 0,
       draftsSync: 0,
-      chatsCount: 40,
-      userAgent: this.userAgent.toJSON()
+      chatsCount: 40
     };
+    payload.userAgent = this.userAgent.toJSON();
 
     const response = await this.sendAndWait(Opcode.LOGIN, payload);
     
     if (response.payload && response.payload.error) {
-      throw new Error(`Sync error: ${JSON.stringify(response.payload.error)}`);
+      const err = response.payload.error;
+      const msg = typeof err === 'string' ? err : (response.payload.localizedMessage || JSON.stringify(err));
+      throw new Error(msg);
     }
     
     // Сохраняем информацию о пользователе
@@ -421,17 +599,58 @@ class WebMaxClient extends EventEmitter {
 
 
   /**
-   * Установка WebSocket соединения
+   * Установка соединения (WebSocket или Socket)
    */
   async connect() {
+    if (this._useSocketTransport) {
+      return this._connectSocket();
+    } else {
+      return this._connectWebSocket();
+    }
+  }
+
+  /**
+   * Подключение через TCP Socket (для IOS/ANDROID)
+   */
+  async _connectSocket() {
+    if (this._socketTransport && this._socketTransport.socket && !this._socketTransport.socket.destroyed) {
+      this.isConnected = true;
+      return;
+    }
+
+    this._socketTransport = new MaxSocketTransport({
+      deviceId: this.deviceId,
+      deviceType: this.userAgent.deviceType,
+      ua: this.userAgent.headerUserAgent,
+      debug: this.debug
+    });
+
+    this._socketTransport.onNotification = (data) => {
+      this.handleSocketNotification(data);
+    };
+
+    await this._socketTransport.connect();
+    await this._socketTransport.handshake(this.userAgent);
+    
+    this.isConnected = true;
+    this.reconnectAttempts = 0;
+    this.emit('connected');
+    
+    console.log('TCP Socket соединение установлено');
+  }
+
+  /**
+   * Установка WebSocket соединения (для WEB)
+   */
+  async _connectWebSocket() {
     if (this.ws && this.isConnected) {
       return;
     }
 
     return new Promise((resolve, reject) => {
       const headers = {
-        'User-Agent': this.userAgent.headerUserAgent,
-        'Origin': this.origin
+        'Origin': this.origin,
+        'User-Agent': this._handshakeUserAgent.headerUserAgent
       };
 
       this.ws = new WebSocket(this.apiUrl, {
@@ -445,7 +664,6 @@ class WebMaxClient extends EventEmitter {
         this.emit('connected');
         
         try {
-          // Выполняем handshake
           await this.handshake();
           resolve();
         } catch (error) {
@@ -466,6 +684,12 @@ class WebMaxClient extends EventEmitter {
       this.ws.on('close', () => {
         console.log('WebSocket соединение закрыто');
         this.isConnected = false;
+        const err = new Error('Соединение закрыто');
+        for (const [, pending] of this.pendingRequests) {
+          if (pending.timeoutId) clearTimeout(pending.timeoutId);
+          pending.reject(err);
+        }
+        this.pendingRequests.clear();
         this.triggerHandlers(EventTypes.DISCONNECT);
         this.handleReconnect();
       });
@@ -480,7 +704,7 @@ class WebMaxClient extends EventEmitter {
     
     const payload = {
       deviceId: this.deviceId,
-      userAgent: this.userAgent.toJSON()
+      userAgent: this._handshakeUserAgent.toJSON()
     };
 
     const response = await this.sendAndWait(Opcode.SESSION_INIT, payload);
@@ -493,6 +717,41 @@ class WebMaxClient extends EventEmitter {
     return response;
   }
 
+  /**
+   * Обработка уведомлений от Socket транспорта
+   */
+  async handleSocketNotification(data) {
+    try {
+      if (this.debug && data.opcode !== Opcode.PING) {
+        const payload = data.payload?.error ? ` error=${JSON.stringify(data.payload.error)}` : '';
+        console.log(`📥 ${getOpcodeName(data.opcode)} (seq=${data.seq})${payload}`);
+      }
+
+      switch (data.opcode) {
+        case Opcode.NOTIF_MESSAGE:
+          await this.handleNewMessage(data.payload);
+          break;
+          
+        case Opcode.NOTIF_MSG_DELETE:
+          await this.handleRemovedMessage(data.payload);
+          break;
+          
+        case Opcode.NOTIF_CHAT:
+          await this.handleChatAction(data.payload);
+          break;
+
+        case Opcode.PING:
+          break;
+          
+        default:
+          this.emit('raw_message', data);
+      }
+    } catch (error) {
+      console.error('Ошибка при обработке Socket уведомления:', error);
+      await this.triggerHandlers(EventTypes.ERROR, error);
+    }
+  }
+
   /**
    * Обработка переподключения
    */
@@ -510,16 +769,16 @@ class WebMaxClient extends EventEmitter {
   }
 
   /**
-   * Обработка входящих сообщений
+   * Обработка входящих сообщений (WebSocket)
    */
   async handleMessage(data) {
     try {
       const message = JSON.parse(data.toString());
       
-      // Отладочное логирование (раскомментируйте при необходимости)
-      // if (message.opcode !== Opcode.PING) {
-      //   console.log(`📥 Получено: ${getOpcodeName(message.opcode)} (seq=${message.seq})`);
-      // }
+      if (this.debug && message.opcode !== Opcode.PING) {
+        const payload = message.payload?.error ? ` error=${JSON.stringify(message.payload.error)}` : '';
+        console.log(`📥 ${getOpcodeName(message.opcode)} (seq=${message.seq})${payload}`);
+      }
       
       // Обработка ответов на запросы по seq
       if (message.seq && this.pendingRequests.has(message.seq)) {
@@ -549,7 +808,6 @@ class WebMaxClient extends EventEmitter {
           break;
 
         case Opcode.PING:
-          // Отвечаем на ping (без логирования)
           await this.sendPong();
           break;
           
@@ -629,21 +887,25 @@ class WebMaxClient extends EventEmitter {
   }
 
   /**
-   * Отправка запроса через WebSocket и ожидание ответа
+   * Отправка запроса и ожидание ответа
    */
-  sendAndWait(opcode, payload, cmd = 0, timeout = 20000) {
-    return new Promise((resolve, reject) => {
-      if (!this.isConnected) {
-        reject(new Error('WebSocket не подключен'));
-        return;
-      }
+  async sendAndWait(opcode, payload, cmd = 0, timeout = 20000) {
+    if (!this.isConnected) {
+      throw new Error('Соединение не установлено');
+    }
 
+    // Используем Socket транспорт для IOS/ANDROID
+    if (this._useSocketTransport && this._socketTransport) {
+      return await this._socketTransport.sendAndWait(opcode, payload, cmd, timeout);
+    }
+
+    // WebSocket транспорт для WEB
+    return new Promise((resolve, reject) => {
       const message = this.makeMessage(opcode, payload, cmd);
       const seq = message.seq;
 
       this.pendingRequests.set(seq, { resolve, reject });
 
-      // Таймаут для запроса
       const timeoutId = setTimeout(() => {
         if (this.pendingRequests.has(seq)) {
           this.pendingRequests.delete(seq);
@@ -651,19 +913,14 @@ class WebMaxClient extends EventEmitter {
         }
       }, timeout);
 
-      // Сохраняем timeoutId чтобы можно было отменить
       this.pendingRequests.get(seq).timeoutId = timeoutId;
 
-      // Отладочное логирование (раскомментируйте при необходимости)
-      // if (opcode !== Opcode.PING) {
-      //   console.log(`📤 Отправка: ${getOpcodeName(opcode)} (seq=${seq})`);
-      // }
       this.ws.send(JSON.stringify(message));
     });
   }
 
   /**
-   * Отправка сообщения
+   * Отправка сообщения (с уведомлением)
    */
   async sendMessage(options) {
     if (typeof options === 'string') {
@@ -672,6 +929,37 @@ class WebMaxClient extends EventEmitter {
 
     const { chatId, text, cid, replyTo, attachments } = options;
 
+    const payload = {
+      chatId: chatId,
+      message: {
+        text: text || '',
+        cid: cid || Date.now(),
+        elements: [],
+        attaches: attachments || [],
+        link: replyTo ? { type: 'REPLY', messageId: replyTo } : null
+      },
+      notify: true
+    };
+
+    const response = await this.sendAndWait(Opcode.MSG_SEND, payload);
+
+    if (response.payload && response.payload.message) {
+      return new Message(response.payload.message, this);
+    }
+    
+    return response.payload;
+  }
+
+  /**
+   * Отправка сообщения в канал (без уведомления)
+   */
+  async sendMessageChannel(options) {
+    if (typeof options === 'string') {
+      throw new Error('sendMessageChannel требует объект с параметрами: { chatId, text, cid }');
+    }
+
+    const { chatId, text, cid, replyTo, attachments } = options;
+
     const payload = {
       chatId: chatId,
       message: {
@@ -769,6 +1057,10 @@ class WebMaxClient extends EventEmitter {
    * Получение списка чатов
    */
   async getChats(marker = 0) {
+    if (this._useSocketTransport && this._socketTransport) {
+      return await this._socketTransport.getChats(marker);
+    }
+
     const payload = {
       marker: marker
     };
@@ -782,6 +1074,11 @@ class WebMaxClient extends EventEmitter {
    * Получение истории сообщений
    */
   async getHistory(chatId, from = Date.now(), backward = 200, forward = 0) {
+    if (this._useSocketTransport && this._socketTransport) {
+      const messages = await this._socketTransport.getHistory(chatId, from, backward, forward);
+      return messages.map(msg => new Message(msg, this));
+    }
+
     const payload = {
       chatId: chatId,
       from: from,
@@ -819,6 +1116,10 @@ class WebMaxClient extends EventEmitter {
    * Остановка клиента
    */
   async stop() {
+    if (this._socketTransport) {
+      await this._socketTransport.close();
+      this._socketTransport = null;
+    }
     if (this.ws) {
       this.ws.close();
       this.ws = null;

package/lib/opcodes.js

@@ -1,6 +1,5 @@
 /**
  * Opcodes для протокола Max API
- * Портировано из PyMax
  */
 
 const Opcode = {
@@ -10,6 +9,8 @@ const Opcode = {
   LOG: 5,
   SESSION_INIT: 6,
   PROFILE: 16,
+  AUTH_REQUEST: 17,
+  AUTH: 18,
   LOGIN: 19,
   LOGOUT: 20,
   SYNC: 21,
@@ -40,6 +41,7 @@ const Opcode = {
   NOTIF_MESSAGE: 128,
   NOTIF_CHAT: 135,
   NOTIF_ATTACH: 136,
+  NOTIF_MSG_DELETE: 154,
   NOTIF_MSG_REACTIONS_CHANGED: 155,
   MSG_REACTION: 178,
   MSG_CANCEL_REACTION: 179,