webmaxsocket 1.0.0 → 1.1.1

package/lib/client.js

@@ -1,13 +1,59 @@
+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);
+}
+
+/**
+ * Понятная ошибка при отказе сервера отдать QR (часто qr_login.disabled для неофициального WEB-handshake).
+ */
+function throwIfGetQRRejected(payload) {
+  if (!payload || !payload.error) {
+    return;
+  }
+  const err = payload.error;
+  const text =
+    typeof err === 'string'
+      ? err
+      : err && typeof err.message === 'string'
+        ? err.message
+        : JSON.stringify(err);
+  if (String(text).includes('qr_login.disabled')) {
+    throw new Error(
+      'Сервер Max отказал в выдаче QR (qr_login.disabled). Частые причины: устаревший appVersion в User-Agent (нужно ≥ 25.12.13), ' +
+      'или отключение QR для данного клиента на стороне VK. Проверьте https://web.max.ru в браузере. ' +
+      'Второй телефон к аккаунту можно добавить и обычным входом по номеру в приложении Max.'
+    );
+  }
+  throw new Error(`QR request error: ${text}`);
+}
+
 /**
  * Основной клиент для работы с API Max
  */
@@ -18,20 +64,63 @@ 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: options.locale || configObj.locale || 'ru',
+      deviceLocale: options.deviceLocale || configObj.deviceLocale || configObj.locale || 'ru',
+      osVersion:
+        options.osVersion ||
+        configObj.osVersion ||
+        (deviceType === 'IOS' ? '18.6.2' : deviceType === 'ANDROID' ? '14' : 'Windows 11'),
+      deviceName:
+        options.deviceName ||
+        configObj.deviceName ||
+        (deviceType === 'IOS' ? 'Safari' : deviceType === 'ANDROID' ? 'Chrome' : 'Chrome'),
+      headerUserAgent: options.headerUserAgent || options.ua || uaString,
+      // Ниже 25.12.13 сервер может отвечать qr_login.disabled на GET_QR (см. PyMax _login).
+      appVersion: options.appVersion || configObj.appVersion || '25.12.14',
+      screen:
+        options.screen ||
+        configObj.screen ||
+        (deviceType === 'IOS' ? '390x844 3.0x' : deviceType === 'ANDROID' ? '360x780 3.0x' : '1080x1920 1.0x'),
+      timezone: options.timezone || configObj.timezone || 'Europe/Moscow',
+      buildNumber: options.buildNumber ?? configObj.buildNumber,
+      clientSessionId: options.clientSessionId ?? configObj.clientSessionId ?? this.session.get('clientSessionId'),
+      release: options.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 +144,7 @@ class WebMaxClient extends EventEmitter {
 
     this.messageQueue = [];
     this.pendingRequests = new Map();
+    this.debug = options.debug || process.env.DEBUG === '1';
   }
 
   /**
@@ -135,22 +225,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 {
@@ -178,11 +281,9 @@ class WebMaxClient extends EventEmitter {
     console.log('Запрос QR-кода для авторизации...');
     
     const response = await this.sendAndWait(Opcode.GET_QR, {});
-    
-    if (response.payload && response.payload.error) {
-      throw new Error(`QR request error: ${JSON.stringify(response.payload.error)}`);
-    }
-    
+
+    throwIfGetQRRejected(response.payload);
+
     return response.payload;
   }
 
@@ -246,6 +347,127 @@ class WebMaxClient extends EventEmitter {
     }
   }
 
+  /**
+   * Вывести в консоль QR-код для привязки нового устройства (тот же поток, что и веб-вход).
+   * Требуется уже авторизованная сессия (после SMS/QR и sync).
+   * На телефоне: Профиль → Устройства / Безопасность → Подключить устройство (QR).
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.waitForScan=true] — ждать, пока QR отсканируют
+   * @param {boolean} [options.small=true] — компактный QR в терминале
+   * @returns {Promise<{ qrLink: string, trackId: string, pollingInterval: number, expiresAt: number }>}
+   */
+  async showLinkDeviceQR(options = {}) {
+    const { waitForScan = true, small = true } = options;
+
+    if (!this.isConnected) {
+      throw new Error('Нет соединения: сначала await client.connect()');
+    }
+    if (!this.isAuthorized) {
+      throw new Error('Нужна авторизация: войдите в аккаунт и выполните sync, затем вызывайте showLinkDeviceQR');
+    }
+
+    // После LOGIN по TCP сервер не принимает GET_QR («Недопустимое состояние сессии») — тот же QR, что в веб-клиенте, только до авторизации по WebSocket.
+    if (this._useSocketTransport) {
+      return await this._showLinkDeviceQRViaEphemeralWeb(options);
+    }
+
+    console.log('Запрос QR-кода для привязки устройства...');
+    const response = await this.sendAndWait(Opcode.GET_QR, {});
+
+    throwIfGetQRRejected(response.payload);
+
+    const qrData = response.payload;
+    if (!qrData.qrLink || !qrData.trackId || !qrData.pollingInterval || !qrData.expiresAt) {
+      throw new Error('Неполные данные QR-кода от сервера');
+    }
+
+    await this._printLinkDeviceQRConsole(qrData.qrLink, small);
+    console.log('\n💡 Или откройте ссылку: ' + qrData.qrLink);
+    console.log('='.repeat(70) + '\n');
+
+    if (waitForScan) {
+      await this.pollQRStatus(qrData.trackId, qrData.pollingInterval, qrData.expiresAt);
+      console.log('\n✅ Устройство подключено. Проверьте вход на телефоне.');
+    }
+
+    return {
+      qrLink: qrData.qrLink,
+      trackId: qrData.trackId,
+      pollingInterval: qrData.pollingInterval,
+      expiresAt: qrData.expiresAt
+    };
+  }
+
+  _printLinkDeviceQRConsole(qrLink, small = true) {
+    console.log('\n' + '='.repeat(70));
+    console.log('📱 ПРИВЯЗКА НОВОГО УСТРОЙСТВА');
+    console.log('='.repeat(70));
+    console.log('\nНа телефоне откройте Max — как при добавлении устройства в приложении:');
+    console.log('➡️  Профиль → Устройства / Безопасность → Подключить устройство (вход по QR)');
+    console.log('📸 Наведите камеру на QR ниже — это тот же поток, что у веб-клиента:\n');
+    return new Promise((resolve) => {
+      qrcode.generate(qrLink, { small }, (qrCode) => {
+        console.log(qrCode);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * QR для привязки устройства при основой сессии на TCP (IOS/ANDROID): кратковременный WEB-клиент без LOGIN.
+   */
+  async _showLinkDeviceQRViaEphemeralWeb(options = {}) {
+    const { waitForScan = true, small = true } = options;
+    const ephemeralName = `_link_qr_${uuidv4().replace(/-/g, '').slice(0, 12)}`;
+    const webQr = new this.constructor({
+      name: ephemeralName,
+      deviceType: 'WEB',
+      debug: this.debug,
+      apiUrl: this.apiUrl,
+      origin: this.origin,
+      maxReconnectAttempts: 0
+    });
+
+    try {
+      console.log(
+        'Отдельное WebSocket-подключение (как у web.max.ru): на уже залогиненном TCP запрос QR другим способом недоступен.'
+      );
+      await webQr.connect();
+
+      const response = await webQr.sendAndWait(Opcode.GET_QR, {});
+      throwIfGetQRRejected(response.payload);
+
+      const qrData = response.payload;
+      if (!qrData.qrLink || !qrData.trackId || !qrData.pollingInterval || !qrData.expiresAt) {
+        throw new Error('Неполные данные QR-кода от сервера');
+      }
+
+      await this._printLinkDeviceQRConsole(qrData.qrLink, small);
+
+      console.log('\n💡 Или откройте ссылку: ' + qrData.qrLink);
+      console.log('='.repeat(70) + '\n');
+
+      if (waitForScan) {
+        await webQr.pollQRStatus(qrData.trackId, qrData.pollingInterval, qrData.expiresAt);
+        await webQr.loginByQR(qrData.trackId);
+        console.log('\n✅ Устройство подключено. Проверьте телефон.');
+      }
+
+      return {
+        qrLink: qrData.qrLink,
+        trackId: qrData.trackId,
+        pollingInterval: qrData.pollingInterval,
+        expiresAt: qrData.expiresAt
+      };
+    } finally {
+      try {
+        await webQr.stop();
+        webQr.session.destroy();
+      } catch (_) {}
+    }
+  }
+
   /**
    * Авторизация через QR-код
    */
@@ -262,13 +484,15 @@ class WebMaxClient extends EventEmitter {
       console.log('\n' + '='.repeat(70));
       console.log('🔐 АВТОРИЗАЦИЯ ЧЕРЕЗ QR-КОД');
       console.log('='.repeat(70));
-      console.log('\n📱 Откройте приложение Max на телефоне');
-      console.log('➡️  Настройки → Устройства → Подключить устройство');
+      console.log('\n📱 На телефоне: Профиль → Устройства / Безопасность → Подключить устройство');
       console.log('📸 Отсканируйте QR-код ниже:\n');
       
-      // Отображаем QR-код в консоли
-      qrcode.generate(qrData.qrLink, { small: true }, (qrCode) => {
-        console.log(qrCode);
+      // Отображаем QR-код в консоли (ждём вывод, затем опрос статуса)
+      await new Promise((resolve) => {
+        qrcode.generate(qrData.qrLink, { small: true }, (qrCode) => {
+          console.log(qrCode);
+          resolve();
+        });
       });
       
       console.log('\n💡 Или откройте ссылку: ' + qrData.qrLink);
@@ -288,12 +512,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 +542,105 @@ class WebMaxClient extends EventEmitter {
   }
 
   /**
-   * Авторизация пользователя через QR-код
+   * Авторизация по номеру телефона через SMS (для IOS/ANDROID)
+   */
+  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() {
-    console.log('🔐 Авторизация через QR-код');
-    await this.authorizeByQR();
+  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 +663,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 +754,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 +819,6 @@ class WebMaxClient extends EventEmitter {
         this.emit('connected');
         
         try {
-          // Выполняем handshake
           await this.handshake();
           resolve();
         } catch (error) {
@@ -466,6 +839,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 +859,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 +872,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 +924,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 +963,6 @@ class WebMaxClient extends EventEmitter {
           break;
 
         case Opcode.PING:
-          // Отвечаем на ping (без логирования)
           await this.sendPong();
           break;
           
@@ -629,21 +1042,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 +1068,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 +1084,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 +1212,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 +1229,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 +1271,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;