webmaxsocket 1.1.4 → 1.1.6

package/README.md

@@ -31,12 +31,18 @@
 npm install webmaxsocket
 ```
 
-### Зависимости для Socket транспорта (IOS/ANDROID)
+### Зависимости для Socket транспорта (IOS/ANDROID) / Socket transport dependencies
 
-Для работы с TCP Socket транспортом требуется библиотека `lz4`. Если при установке возникают проблемы с `node-gyp`:
+Ответы сервера по TCP содержат полезную нагрузку в **LZ4**-блоках (поверх **msgpack**). Для распаковки используется **`lz4js`** — чистый JavaScript, **без node-gyp** и нативной сборки, в том числе на Windows без Visual Studio C++. Он входит в зависимости `webmaxsocket` и ставится вместе с пакетом. При необходимости можно доустановить вручную:
 
 ```bash
-npm install lz4 --ignore-scripts
+npm install lz4js
+```
+
+Дополнительно можно установить нативный модуль **`lz4`**, если в окружении доступна сборка C++:
+
+```bash
+npm install lz4
 ```
 
 **Примечание:** Для обычной QR-авторизации (WEB) дополнительные зависимости не нужны. Socket транспорт используется только после сохранения сессии или при явном указании `deviceType: 'IOS'`/`'ANDROID'`.
@@ -668,7 +674,7 @@ ChatActions.RECORDING_VIDEO // Записывает видео
 
 ### MaxSocketTransport
 
-Низкоуровневый TCP Socket транспорт для IOS/ANDROID (api.oneme.ru).
+Низкоуровневый TCP Socket транспорт для IOS/ANDROID (api.oneme.ru). Входящие пакеты с флагом сжатия распаковываются через **LZ4** (см. раздел **«Зависимости для Socket транспорта»** выше).
 
 #### Прямое использование (advanced)
 
@@ -827,6 +833,8 @@ DEBUG=1 node example.js
 
 7. **TCP и keep-alive (PING):** сервер периодически шлёт `PING`. На WebSocket клиент отвечает `sendPong`; на **TCP** раньше ответ не отправлялся — соединение могло обрываться через несколько минут, после чего процесс Node **завершался** (нечем держать event loop). Сейчас на TCP автоматически шлётся тот же ответ, что и у WebSocket (`PING` с пустым payload).
 
+8. **LZ4:** для IOS/ANDROID входящие данные распаковываются из LZ4-блоков; **`lz4js`** входит в зависимости пакета. При необходимости можно установить нативный **`lz4`** (см. раздел **«Зависимости для Socket транспорта»**).
+
 ## 🔗 Ссылки / Links
 
 - [GitHub Repository](https://github.com/Tellarion/webmaxsocket)

package/api.package.md

@@ -2,6 +2,8 @@
 
 Краткий перечень возможностей для работы с библиотекой. Подробности и примеры — в `README.md`.
 
+**Зависимости TCP (IOS/ANDROID):** ответы по сокету сжаты **LZ4**; для распаковки используется **`lz4js`**. См. `README.md` → «Зависимости для Socket транспорта».
+
 ---
 
 ## Экспорт пакета (`require('webmaxsocket')`)

package/index.js

@@ -13,6 +13,7 @@ const { Opcode, getOpcodeName } = require('./lib/opcodes');
 const { UserAgentPayload } = require('./lib/userAgent');
 const { downloadUrlToTempFile, extFromContentType, extFromAttachType } = require('./lib/downloadMedia');
 const { resolveIncomingLogMode, printIncomingLog } = require('./lib/incomingLog');
+const { parseQrTrackId } = require('./lib/qrWebLogin');
 
 module.exports = {
   WebMaxClient,
@@ -30,6 +31,7 @@ module.exports = {
   extFromContentType,
   extFromAttachType,
   resolveIncomingLogMode,
-  printIncomingLog
+  printIncomingLog,
+  parseQrTrackId
 };
 

package/lib/client.js

@@ -11,6 +11,7 @@ const { EventTypes, ChatActions } = require('./constants');
 const { Opcode, DeviceType, getOpcodeName } = require('./opcodes');
 const { UserAgentPayload } = require('./userAgent');
 const { resolveIncomingLogMode, printIncomingLog } = require('./incomingLog');
+const { parseQrTrackId } = require('./qrWebLogin');
 
 /**
  * Загружает конфиг: { token, agent }
@@ -67,46 +68,73 @@ class WebMaxClient extends EventEmitter {
     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;
+
+    const optTok = options.token;
+    this._explicitOptionToken =
+      optTok !== undefined && optTok !== null && String(optTok).trim() !== ''
+        ? String(optTok).trim()
+        : null;
+    this._configFileToken =
+      configPath &&
+      configObj.token !== undefined &&
+      configObj.token !== null &&
+      String(configObj.token).trim() !== ''
+        ? String(configObj.token).trim()
+        : null;
+    /** Сырые токены из опций/config (без sessions); приоритет при старте см. _resolveTokenForStart */
+    this._providedToken = this._explicitOptionToken || this._configFileToken;
     this._saveTokenToSession = options.saveToken !== false;
-    this.origin = 'https://web.max.ru';
+    this.origin = options.origin || 'https://web.max.ru';
+    /** Доп. заголовок для ws (например Referer при QR с max.ru, пока Origin остаётся web.max.ru — иначе 403). */
+    this._wsReferer = options.referer || options.wsReferer || null;
     this.session = new SessionManager(this.sessionName);
     
     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 uaString =
+      agent ||
+      configObj.headerUserAgent ||
+      configObj.ua ||
+      this.session.get('headerUserAgent') ||
+      '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',
+      locale: options.locale || configObj.locale || this.session.get('locale') || 'ru',
+      deviceLocale:
+        options.deviceLocale ||
+        configObj.deviceLocale ||
+        configObj.locale ||
+        this.session.get('deviceLocale') ||
+        this.session.get('locale') ||
+        'ru',
       osVersion:
         options.osVersion ||
         configObj.osVersion ||
+        this.session.get('osVersion') ||
         (deviceType === 'IOS' ? '18.6.2' : deviceType === 'ANDROID' ? '14' : 'Windows 11'),
       deviceName:
         options.deviceName ||
         configObj.deviceName ||
+        this.session.get('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',
+      appVersion: options.appVersion || configObj.appVersion || this.session.get('appVersion') || '26.3.9',
       screen:
         options.screen ||
         configObj.screen ||
+        this.session.get('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,
+      timezone: options.timezone || configObj.timezone || this.session.get('timezone') || 'Europe/Moscow',
+      buildNumber: options.buildNumber ?? configObj.buildNumber ?? this.session.get('buildNumber'),
       clientSessionId: options.clientSessionId ?? configObj.clientSessionId ?? this.session.get('clientSessionId'),
       release: options.release ?? configObj.release
     };
@@ -127,8 +155,8 @@ class WebMaxClient extends EventEmitter {
     this.isConnected = false;
     this.isAuthorized = false;
     this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
-    this.reconnectDelay = options.reconnectDelay || 3000;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    this.reconnectDelay = options.reconnectDelay ?? 3000;
     
     // Protocol fields
     this.seq = 0;
@@ -149,6 +177,9 @@ class WebMaxClient extends EventEmitter {
       Boolean(options.debug) ||
       process.env.DEBUG === '1' ||
       process.env.WEBMAX_DEBUG === '1';
+    this._authDebug = Boolean(options.authDebug) || process.env.WEBMAX_AUTH_DEBUG === '1';
+    /** После успешного sync копировать sessions/<name>.json → <name>.last_ok.json */
+    this._sessionBackupOnSuccess = options.sessionBackup !== false;
     /** Режим JSON-лога входящих: off | messages | verbose (см. logIncoming в README) */
     this._incomingLogMode = resolveIncomingLogMode(options);
     this._wireIncomingLogListeners();
@@ -183,6 +214,55 @@ class WebMaxClient extends EventEmitter {
     });
   }
 
+  /**
+   * Приоритет токена: явный options.token → сохранённая sessions/<name>.json → token из config.
+   * Иначе после SMS в sessions лежит новый токен, а из config подставлялся старый и sync падал с «обновите config».
+   */
+  _resolveTokenForStart() {
+    if (this._explicitOptionToken) {
+      return { token: this._explicitOptionToken, source: 'options.token' };
+    }
+    const sessionTok = this.session.get('token');
+    if (sessionTok && String(sessionTok).trim() !== '') {
+      return { token: String(sessionTok).trim(), source: 'session_file' };
+    }
+    if (this._configFileToken) {
+      return { token: this._configFileToken, source: 'config_file' };
+    }
+    return { token: null, source: null };
+  }
+
+  _logAuthContext(phase, extra = {}) {
+    if (!this.debug && !this._authDebug) return;
+    let libVersion = 'unknown';
+    try {
+      libVersion = require(path.join(__dirname, '..', 'package.json')).version;
+    } catch (_) {
+      /* ignore */
+    }
+    const tok = this._token || this.session.get('token');
+    const tokenPreview =
+      tok && String(tok).length > 14
+        ? `${String(tok).slice(0, 8)}…${String(tok).slice(-4)}`
+        : tok
+          ? '(short)'
+          : '(none)';
+    const payload = {
+      phase,
+      libVersion,
+      node: process.version,
+      cwd: process.cwd(),
+      sessionName: this.sessionName,
+      sessionPath: this.session.sessionFile,
+      backupPath: path.join(this.session.sessionDir, `${this.sessionName}.last_ok.json`),
+      tokenPreview,
+      deviceId: this.deviceId,
+      userAgent: this.userAgent.toJSON(),
+      ...extra
+    };
+    console.log('[webmaxsocket:auth]', JSON.stringify(payload, null, 2));
+  }
+
   /**
    * Регистрация обработчика события start
    */
@@ -264,32 +344,47 @@ class WebMaxClient extends EventEmitter {
       // Подключаемся к WebSocket или Socket
       await this.connect();
       
-      // Приоритет: 1) переданный токен, 2) сохранённая сессия, 3) QR-авторизация
-      const tokenToUse = this._providedToken || this.session.get('token');
-      
+      const { token: tokenToUse, source: tokenSource } = this._resolveTokenForStart();
+
       if (tokenToUse) {
-        if (this._providedToken) {
+        if (tokenSource === 'session_file') {
+          console.log('✅ Найдена сохраненная сессия');
+        } else {
           console.log('✅ Вход по токену (token auth)');
           if (this._saveTokenToSession) {
-            this.session.set('token', this._providedToken);
+            this.session.set('token', tokenToUse);
             this.session.set('deviceId', this.deviceId);
           }
-        } else {
-          console.log('✅ Найдена сохраненная сессия');
         }
         this._token = tokenToUse;
-        
+
+        this._logAuthContext('start:before_sync', { tokenSource });
+
         try {
           await this.sync();
           this.isAuthorized = true;
         } catch (error) {
-          const wasTokenAuth = !!this._providedToken;
+          const fromConfigOrOptions =
+            tokenSource === 'config_file' || tokenSource === 'options.token';
           this.session.clear();
+          this._explicitOptionToken = null;
+          this._configFileToken = null;
           this._providedToken = null;
-          if (wasTokenAuth) {
-            throw new Error(`Токен недействителен или сессия истекла. Обновите токен в config. (${error.message})`);
+          if (fromConfigOrOptions) {
+            throw new Error(
+              `Токен недействителен или сессия истекла. Обновите token в config или удалите/очистите token в config, чтобы использовалась актуальная сессия из sessions/. (${error.message})`
+            );
           }
           console.log('⚠️ Сессия истекла, требуется повторная авторизация');
+          if (this.debug || this._authDebug) {
+            console.log(
+              '[webmaxsocket:auth] Подсказка: для восстановления попробуйте скопировать sessions/' +
+                this.sessionName +
+                '.last_ok.json поверх sessions/' +
+                this.sessionName +
+                '.json (если копия есть).'
+            );
+          }
           await this.authorize();
         }
       } else {
@@ -316,7 +411,7 @@ class WebMaxClient extends EventEmitter {
   async requestQR() {
     console.log('Запрос QR-кода для авторизации...');
     
-    const response = await this.sendAndWait(Opcode.GET_QR, {});
+    const response = await this.sendAndWait(Opcode.GET_QR, undefined);
 
     throwIfGetQRRejected(response.payload);
 
@@ -336,19 +431,456 @@ class WebMaxClient extends EventEmitter {
     return response.payload;
   }
 
+  /**
+   * На TCP после ответа LOGIN сервер может закрыть сокет — перед следующим RPC переподключаемся и снова LOGIN.
+   */
+  async _ensureTcpSocketReadyForRpc() {
+    const st = this._socketTransport;
+    if (st && st.socket && !st.socket.destroyed) return;
+    const token = this._token || this.session.get('token');
+    if (!token) {
+      throw new Error('Нет токена для переподключения TCP');
+    }
+    console.log('Переподключение TCP (сокет закрыт после предыдущего запроса)…');
+    this.isConnected = false;
+    await this.connect();
+    this._token = token;
+    await this.sync();
+    this.isAuthorized = true;
+  }
+
   /**
    * Завершение авторизации по QR-коду
+   * @param {string} trackId — UUID (веб GET_QR) или opaque token `qr_…` (max.ru/qr/v1/auth)
    */
   async loginByQR(trackId) {
-    const response = await this.sendAndWait(Opcode.LOGIN_BY_QR, { trackId });
-    
+    if (this._useSocketTransport) {
+      await this._ensureTcpSocketReadyForRpc();
+    }
+    const id = String(trackId).trim();
+    const payload = id.startsWith('qr_') ? { token: id } : { trackId: id };
+    const response = await this.sendAndWait(Opcode.LOGIN_BY_QR, payload);
+
     if (response.payload && response.payload.error) {
       throw new Error(`QR login error: ${JSON.stringify(response.payload.error)}`);
     }
-    
+
     return response.payload;
   }
 
+  async approveQR(qrLink) {
+    if (this._useSocketTransport) {
+      await this._ensureTcpSocketReadyForRpc();
+    }
+    if (!this.isAuthorized) {
+      throw new Error('Требуется авторизованная сессия для одобрения QR');
+    }
+    const link = String(qrLink).trim();
+    const response = await this.sendAndWait(Opcode.AUTH_QR_APPROVE, { qrLink: link });
+    if (response.payload && response.payload.error) {
+      throw new Error(`QR approve error: ${JSON.stringify(response.payload.error)}`);
+    }
+    return response.payload;
+  }
+
+  /**
+   * LOGIN_BY_QR: как web.max.ru — сначала только trackId (HAR), затем запасные варианты + токен аккаунта.
+   */
+  async _loginByQrWebMax(web, trackId, accountToken) {
+    const id = String(trackId).trim();
+    if (id.startsWith('qr_')) {
+      const response = await web.sendAndWait(Opcode.LOGIN_BY_QR, { token: id });
+      if (response.payload && response.payload.error) {
+        throw new Error(`QR login error: ${JSON.stringify(response.payload.error)}`);
+      }
+      return response.payload;
+    }
+    const payloads = [{ trackId: id }, { track: id }, { authTrackId: id }];
+    if (accountToken) {
+      payloads.push(
+        { trackId: id, token: accountToken },
+        { track: id, token: accountToken },
+        { trackId: id, account_token: accountToken },
+        { track: id, account_token: accountToken }
+      );
+    }
+
+    let lastErr;
+    for (const payload of payloads) {
+      try {
+        const response = await web.sendAndWait(Opcode.LOGIN_BY_QR, payload);
+        if (response.payload && response.payload.error) {
+          const err = response.payload.error;
+          const msg =
+            typeof err === 'string'
+              ? err
+              : err && typeof err.message === 'string'
+                ? err.message
+                : response.payload.localizedMessage || JSON.stringify(err);
+          lastErr = new Error(msg);
+          if (/track\.not\.found/i.test(String(msg))) {
+            throw new Error(
+              `${msg}\n` +
+                'Трек QR устарел или уже использован. Откройте web.max.ru, дождитесь нового QR и сразу сохраните qr.png.'
+            );
+          }
+          if (/proto\.payload/i.test(String(msg))) {
+            continue;
+          }
+          continue;
+        }
+        return response.payload;
+      } catch (e) {
+        lastErr = e;
+        if (e && e.message && /track\.not\.found|Трек QR устарел/i.test(e.message)) {
+          throw e;
+        }
+      }
+    }
+    throw lastErr || new Error('LOGIN_BY_QR не удался');
+  }
+
+  /**
+   * Как в web.max.ru (HAR): опрос GET_QR_STATUS, пока status.loginAvailable !== true (после скана в приложении Max).
+   * Без этого LOGIN_BY_QR часто даёт track.not.found — трек не «готов» к подтверждению.
+   */
+  async _waitForWebQrLoginAvailable(web, trackId, options = {}) {
+    const pollingInterval = options.pollingInterval ?? 5000;
+    const defaultTtlMs = options.defaultTtlMs ?? 180000;
+    let expiresAt = Date.now() + defaultTtlMs;
+
+    console.log(
+      '\n📱 Нужно подтверждение с телефона (как в официальном web-клиенте):\n' +
+        '   Max на телефоне → раздел с входом по QR к веб-версии / устройства — наведите на тот же QR (тот же аккаунт).\n' +
+        '   Чтобы вкладка браузера не отправила LOGIN_BY_QR раньше скрипта: после сохранения qr.png закройте вкладку web.max.ru,\n' +
+        '   затем запустите этот скрипт и отсканируйте QR с файла/второго монитора.\n' +
+        '   Ожидание loginAvailable на сервере…'
+    );
+
+    while (true) {
+      const now = Date.now();
+      if (now >= expiresAt) {
+        throw new Error(
+          'Нет loginAvailable до истечения времени: отсканируйте QR приложением на тот же аккаунт или обновите qr.png.'
+        );
+      }
+
+      const statusResponse = await web.checkQRStatus(trackId);
+      if (statusResponse.status && statusResponse.status.expiresAt != null) {
+        const ex = Number(statusResponse.status.expiresAt);
+        if (Number.isFinite(ex)) {
+          expiresAt = Math.min(expiresAt, ex);
+        }
+      }
+      if (statusResponse.status && statusResponse.status.loginAvailable) {
+        console.log('\n✅ Сервер готов к LOGIN_BY_QR (loginAvailable).');
+        return;
+      }
+
+      process.stdout.write('.');
+
+      const wait = Math.min(
+        pollingInterval,
+        Math.max(0, expiresAt - Date.now())
+      );
+      await new Promise((r) => setTimeout(r, wait || pollingInterval));
+    }
+  }
+
+  /**
+   * Подтверждение входа по QR: новое TCP-соединение (только SESSION_INIT), затем LOGIN_BY_QR — без LOGIN на этом сокете.
+   */
+  async _approveWebLoginByQrViaEphemeralTcp(trackId) {
+    const accountToken = this._token || this.session.get('token');
+    const transport = new MaxSocketTransport({
+      deviceId: this.deviceId,
+      deviceType: this.userAgent.deviceType,
+      ua: this.userAgent.headerUserAgent,
+      debug: this.debug,
+    });
+    await transport.connect();
+    await transport.handshake(this.userAgent);
+    try {
+      const id = String(trackId).trim();
+      if (id.startsWith('qr_')) {
+        const result = await transport.sendAndWait(Opcode.LOGIN_BY_QR, { token: id });
+        return result.payload;
+      }
+      const payloads = [
+        { trackId: id },
+        { track: id },
+        { trackId: id, token: accountToken },
+        { track: id, token: accountToken },
+      ];
+      let lastErr;
+      for (const payload of payloads) {
+        try {
+          const result = await transport.sendAndWait(Opcode.LOGIN_BY_QR, payload);
+          return result.payload;
+        } catch (e) {
+          lastErr = e;
+        }
+      }
+      throw lastErr || new Error('LOGIN_BY_QR (TCP) не удался');
+    } finally {
+      await transport.close();
+    }
+  }
+
+  /**
+   * Подтверждение входа в web.max по QR при основной сессии на TCP: отдельный WebSocket + LOGIN + LOGIN_BY_QR.
+   * На том же TCP после LOGIN сервер не принимает LOGIN_BY_QR («Недопустимое состояние сессии»).
+   * WEB-клиент: не используем IOS deviceId (даёт login.cred); берём webDeviceId из сессии или новый UUID.
+   * Сначала пробуем webToken для sync, затем основной token. Без успешного sync LOGIN_BY_QR часто даёт auth_by_track.no.attempts.
+   */
+  async _approveWebLoginByQrViaEphemeralWeb(trackId, options = {}, qrSource = '') {
+    const {
+      retry = true,
+      saveWebSession = true,
+      waitForPhoneScan = true,
+      qrPollingInterval = 5000,
+    } = options;
+    const accountToken = this._token || this.session.get('token');
+    if (!accountToken) {
+      throw new Error('Нет токена сессии');
+    }
+
+    const refererForMaxQr =
+      /https?:\/\/max\.ru\//i.test(String(qrSource)) && !/web\.max\.ru/i.test(String(qrSource))
+        ? 'https://max.ru/'
+        : null;
+
+    const webUa =
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36';
+    const webDeviceId = this.session.get('webDeviceId') || uuidv4();
+
+    const ephemeralName = `_web_qr_${uuidv4().replace(/-/g, '').slice(0, 12)}`;
+    const web = new this.constructor({
+      name: ephemeralName,
+      deviceType: 'WEB',
+      deviceId: webDeviceId,
+      // Не делим clientSessionId с параллельным TCP (IOS) — иначе сервер может обрывать WS (1006).
+      clientSessionId: Math.floor(Math.random() * 0x7fffffff),
+      headerUserAgent: webUa,
+      appVersion: '26.3.9',
+      screen: '1920x1080 1.0x',
+      osVersion: 'Windows 11',
+      deviceName: 'Chrome',
+      saveToken: false,
+      debug: this.debug,
+      apiUrl: this.apiUrl,
+      origin: 'https://web.max.ru',
+      referer: refererForMaxQr,
+      maxReconnectAttempts: 0
+    });
+    web.handleReconnect = () => {};
+
+    const wrapTrackError = (e) => {
+      const m = e && e.message ? e.message : String(e);
+      if (/auth_by_track|no\.attempts|Недопустимое состояние|track\.not\.found/i.test(m)) {
+        return new Error(
+          `${m}\n` +
+            'Подсказка: WebSocket принимает только Origin web.max.ru; для max.ru/:auth/ добавлен Referer. Сделайте новый скрин qr.png сразу после появления QR; старый трек даёт track.not.found.'
+        );
+      }
+      return e;
+    };
+
+    try {
+      console.log(
+        `Отдельное WebSocket (Origin=web.max.ru${refererForMaxQr ? ', Referer=max.ru' : ''}): ws-api принимает только Origin web.max.ru; при QR с max.ru добавлен Referer.`
+      );
+      await web.connect();
+
+      const webTok = this.session.get('webToken');
+      let syncOk = false;
+      // IOS-токен на WEB даёт login.cred и сервер часто рвёт сокет — не вызываем sync с ним.
+      // Только отдельный webToken из прошлого входа в web.max.
+      if (webTok && webTok !== accountToken) {
+        try {
+          web._token = webTok;
+          await web.sync();
+          syncOk = true;
+          web.isAuthorized = true;
+          if (saveWebSession && web.deviceId) {
+            this.session.set('webDeviceId', web.deviceId);
+          }
+        } catch (e) {
+          const msg = e && e.message ? e.message : String(e);
+          console.log(`WEB LOGIN (sync) с webToken: ${msg}`);
+        }
+      }
+
+      if (waitForPhoneScan) {
+        await this._waitForWebQrLoginAvailable(web, trackId, {
+          pollingInterval: qrPollingInterval,
+        });
+      }
+
+      const attempts = retry ? 2 : 1;
+      let lastErr;
+      for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+          const wsOpen = web.ws && web.ws.readyState === WebSocket.OPEN;
+          if (!web.isConnected || !wsOpen) {
+            console.log('Переподключение WebSocket перед LOGIN_BY_QR (после ошибки LOGIN сокет часто закрывается)…');
+            if (web.ws) {
+              try {
+                web.ws.removeAllListeners();
+              } catch (_) {}
+              try {
+                web.ws.close();
+              } catch (_) {}
+              web.ws = null;
+            }
+            web.isConnected = false;
+            web.pendingRequests.clear();
+            await web.connect();
+          }
+
+          let loginData;
+          if (syncOk) {
+            loginData = await this._loginByQrWebMax(web, trackId, null);
+          } else {
+            loginData = await this._loginByQrWebMax(web, trackId, accountToken);
+          }
+
+          if (saveWebSession && loginData && typeof loginData === 'object') {
+            this.session.set('webQrTrackId', trackId);
+            const loginAttrs = loginData.tokenAttrs && loginData.tokenAttrs.LOGIN;
+            const wtoken = loginAttrs && loginAttrs.token;
+            if (wtoken) {
+              this.session.set('webToken', wtoken);
+            }
+            if (loginData.deviceId != null) {
+              this.session.set('webDeviceId', loginData.deviceId);
+            }
+            if (loginData.clientSessionId != null) {
+              this.session.set('webClientSessionId', loginData.clientSessionId);
+            }
+          }
+
+          console.log('✅ Вход в веб-версию по QR подтверждён (LOGIN_BY_QR через WebSocket)');
+          return loginData;
+        } catch (e) {
+          lastErr = wrapTrackError(e);
+          if (attempt < attempts) {
+            await new Promise((r) => setTimeout(r, 400));
+            continue;
+          }
+          throw lastErr;
+        }
+      }
+      throw lastErr;
+    } finally {
+      try {
+        await web.stop();
+        web.session.destroy();
+      } catch (_) {}
+    }
+  }
+
+  /**
+   * Подтвердить вход в веб-версию (web.max.ru) по URL из QR или trackId,
+   * используя уже авторизованную сессию (в т.ч. TCP после SMS/токена).
+   * Аналог сценария с `qr_url` + `account_token` на сторонних сервисах: здесь токен уже в сессии.
+   *
+   * @param {string} qrUrlOrTrackId — полный URL из QR, либо UUID trackId
+   * @param {{ retry?: boolean, saveWebSession?: boolean, waitForPhoneScan?: boolean, qrPollingInterval?: number }} [options]
+   * @returns {Promise<object>} payload ответа LOGIN_BY_QR
+   */
+  async approveWebLoginByQr(qrUrlOrTrackId, options = {}) {
+    const { retry = true, saveWebSession = true } = options;
+
+    const trackId = parseQrTrackId(qrUrlOrTrackId);
+    if (!trackId) {
+      throw new Error(
+        'Не удалось извлечь идентификатор из QR: ожидается URL max.ru/qr/v1/auth?token=qr_…, web.max с trackId или UUID'
+      );
+    }
+
+    const token = this._token || this.session.get('token');
+    if (!token) {
+      throw new Error('Нет токена в сессии для подтверждения входа');
+    }
+
+    if (this._useSocketTransport) {
+      if (!this.isAuthorized) {
+        throw new Error(
+          'Нужна авторизованная сессия: выполните connect() + sync() с действующим токеном'
+        );
+      }
+      if (process.env.MAX_QR_TRY_TCP_FIRST === '1') {
+        try {
+          const loginData = await this._approveWebLoginByQrViaEphemeralTcp(trackId);
+          if (saveWebSession && loginData && typeof loginData === 'object') {
+            this.session.set('webQrTrackId', trackId);
+            const loginAttrs = loginData.tokenAttrs && loginData.tokenAttrs.LOGIN;
+            const wtoken = loginAttrs && loginAttrs.token;
+            if (wtoken) {
+              this.session.set('webToken', wtoken);
+            }
+            if (loginData.deviceId != null) {
+              this.session.set('webDeviceId', loginData.deviceId);
+            }
+            if (loginData.clientSessionId != null) {
+              this.session.set('webClientSessionId', loginData.clientSessionId);
+            }
+          }
+          console.log('✅ Вход в веб-версию по QR подтверждён (LOGIN_BY_QR, новое TCP-соединение)');
+          return loginData;
+        } catch (e) {
+          const msg = e && e.message ? e.message : String(e);
+          console.log(`LOGIN_BY_QR по новому TCP: ${msg} — пробуем WebSocket (Origin web.max.ru)…`);
+        }
+      }
+      return await this._approveWebLoginByQrViaEphemeralWeb(trackId, options, qrUrlOrTrackId);
+    }
+
+    if (!this.isConnected) {
+      throw new Error('Нет соединения: сначала await client.connect()');
+    }
+    if (!this.isAuthorized) {
+      throw new Error(
+        'Нужна авторизованная сессия: выполните start() или connect() + sync() с действующим токеном'
+      );
+    }
+
+    let lastErr;
+    const attempts = retry ? 2 : 1;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        const loginData = await this.loginByQR(trackId);
+
+        if (saveWebSession && loginData && typeof loginData === 'object') {
+          this.session.set('webQrTrackId', trackId);
+          const loginAttrs = loginData.tokenAttrs && loginData.tokenAttrs.LOGIN;
+          const wtoken = loginAttrs && loginAttrs.token;
+          if (wtoken) {
+            this.session.set('webToken', wtoken);
+          }
+          if (loginData.deviceId != null) {
+            this.session.set('webDeviceId', loginData.deviceId);
+          }
+          if (loginData.clientSessionId != null) {
+            this.session.set('webClientSessionId', loginData.clientSessionId);
+          }
+        }
+
+        console.log('✅ Вход в веб-версию по QR подтверждён (LOGIN_BY_QR)');
+        return loginData;
+      } catch (e) {
+        lastErr = e;
+        if (attempt < attempts) {
+          await new Promise((r) => setTimeout(r, 400));
+          continue;
+        }
+        throw e;
+      }
+    }
+    throw lastErr;
+  }
+
   /**
    * Опрос статуса QR-кода
    */
@@ -409,7 +941,7 @@ class WebMaxClient extends EventEmitter {
     }
 
     console.log('Запрос QR-кода для привязки устройства...');
-    const response = await this.sendAndWait(Opcode.GET_QR, {});
+    const response = await this.sendAndWait(Opcode.GET_QR, undefined);
 
     throwIfGetQRRejected(response.payload);
 
@@ -471,7 +1003,7 @@ class WebMaxClient extends EventEmitter {
       );
       await webQr.connect();
 
-      const response = await webQr.sendAndWait(Opcode.GET_QR, {});
+      const response = await webQr.sendAndWait(Opcode.GET_QR, undefined);
       throwIfGetQRRejected(response.payload);
 
       const qrData = response.payload;
@@ -648,10 +1180,11 @@ class WebMaxClient extends EventEmitter {
           this._token = token;
           
           console.log('✅ Авторизация по SMS успешна!');
-          
+          this._logAuthContext('sms:after_login', { tokenSource: 'sms' });
+
           // Выполняем sync
           await this.sync();
-          
+
           return token;
         }
       };
@@ -685,7 +1218,9 @@ class WebMaxClient extends EventEmitter {
    */
   async sync() {
     console.log('🔄 Синхронизация с сервером...');
-    
+
+    this._logAuthContext('sync');
+
     const token = this._token || this.session.get('token');
     
     if (!token) {
@@ -735,7 +1270,27 @@ class WebMaxClient extends EventEmitter {
     } else {
       console.log('⚠️ Данные пользователя не найдены в ответе sync');
     }
-    
+
+    try {
+      let libVersion = 'unknown';
+      try {
+        libVersion = require(path.join(__dirname, '..', 'package.json')).version;
+      } catch (_) {
+        /* ignore */
+      }
+      this.session.set('_authMeta', {
+        lastSyncOkAt: new Date().toISOString(),
+        webmaxsocket: libVersion,
+        node: process.version
+      });
+    } catch (_) {
+      /* ignore */
+    }
+    if (this._sessionBackupOnSuccess) {
+      this.session.copyToLastOk();
+    }
+    this._logAuthContext('sync:ok', { userId: this.me?.id });
+
     return responsePayload;
   }
 
@@ -773,13 +1328,18 @@ class WebMaxClient extends EventEmitter {
       }
       
       this._token = token;
-      
+
+      this._logAuthContext('connectWithSession:before_sync', { tokenSource: 'session_file' });
+
       try {
         await this.sync();
         this.isAuthorized = true;
         console.log('Подключение с сохраненной сессией успешно');
       } catch (error) {
         console.log('Сессия истекла, требуется повторная авторизация');
+        if (this.debug || this._authDebug) {
+          console.log('[webmaxsocket:auth] sync error:', error.message);
+        }
         this.session.clear();
         await this.authorize();
       }
@@ -840,9 +1400,12 @@ class WebMaxClient extends EventEmitter {
 
     return new Promise((resolve, reject) => {
       const headers = {
-        'Origin': this.origin,
+        Origin: this.origin,
         'User-Agent': this._handshakeUserAgent.headerUserAgent
       };
+      if (this._wsReferer) {
+        headers.Referer = this._wsReferer;
+      }
 
       this.ws = new WebSocket(this.apiUrl, {
         headers: headers
@@ -872,8 +1435,9 @@ class WebMaxClient extends EventEmitter {
         reject(error);
       });
 
-      this.ws.on('close', () => {
-        console.log('WebSocket соединение закрыто');
+      this.ws.on('close', (code, reason) => {
+        const rs = reason && reason.length ? reason.toString() : '';
+        console.log(`WebSocket соединение закрыто (code=${code}${rs ? `, ${rs}` : ''})`);
         this.isConnected = false;
         const err = new Error('Соединение закрыто');
         for (const [, pending] of this.pendingRequests) {
@@ -959,10 +1523,13 @@ class WebMaxClient extends EventEmitter {
    * Обработка переподключения
    */
   handleReconnect() {
+    if (this.maxReconnectAttempts <= 0) {
+      return;
+    }
     if (this.reconnectAttempts < this.maxReconnectAttempts) {
       this.reconnectAttempts++;
       console.log(`Попытка переподключения ${this.reconnectAttempts}/${this.maxReconnectAttempts}...`);
-      
+
       setTimeout(() => {
         this.connect();
       }, this.reconnectDelay);
@@ -983,8 +1550,12 @@ class WebMaxClient extends EventEmitter {
         console.log(`📥 ${getOpcodeName(message.opcode)} (seq=${message.seq})${payload}`);
       }
       
-      // Обработка ответов на запросы по seq
-      if (message.seq && this.pendingRequests.has(message.seq)) {
+      // Обработка ответов на запросы по seq (seq может быть 0 — не использовать truthiness)
+      if (
+        message.seq !== undefined &&
+        message.seq !== null &&
+        this.pendingRequests.has(message.seq)
+      ) {
         const pending = this.pendingRequests.get(message.seq);
         this.pendingRequests.delete(message.seq);
         
@@ -1090,17 +1661,21 @@ class WebMaxClient extends EventEmitter {
 
   /**
    * Создает сообщение в протоколе Max API
+   * payload не включаем в JSON, если undefined — как web.max.ru для GET_QR (только opcode).
    */
   makeMessage(opcode, payload, cmd = 0) {
     this.seq += 1;
-    
-    return {
+
+    const message = {
       ver: this.ver,
       cmd: cmd,
       seq: this.seq,
       opcode: opcode,
-      payload: payload
     };
+    if (payload !== undefined) {
+      message.payload = payload;
+    }
+    return message;
   }
 
   /**

package/lib/opcodes.js

@@ -1,7 +1,3 @@
-/**
- * Opcodes для протокола Max API
- */
-
 const Opcode = {
   PING: 1,
   DEBUG: 2,
@@ -30,7 +26,6 @@ const Opcode = {
   UPLOAD_ATTACH_PREP: 65,
   MSG_DELETE: 66,
   MSG_EDIT: 67,
-  /** Подписка / отписка на канал (subscribe: true|false) */
   CHAT_SUBSCRIBE: 75,
   CHAT_MEMBERS_UPDATE: 77,
   PHOTO_UPLOAD: 80,
@@ -54,18 +49,15 @@ const Opcode = {
   FOLDERS_DELETE: 276,
   GET_QR: 288,
   GET_QR_STATUS: 289,
+  AUTH_QR_APPROVE: 290,
   LOGIN_BY_QR: 291,
 };
 
-// Обратная карта для расшифровки опкодов
 const OpcodeNames = {};
 for (const [name, code] of Object.entries(Opcode)) {
   OpcodeNames[code] = name;
 }
 
-/**
- * Получить название опкода
- */
 function getOpcodeName(code) {
   return OpcodeNames[code] || `UNKNOWN_${code}`;
 }

package/lib/qrWebLogin.js

@@ -0,0 +1,59 @@
+/**
+ * Извлекает идентификатор входа по QR: UUID trackId или opaque token (qr_…).
+ * Поддерживаются:
+ * - https://max.ru/qr/v1/auth?token=qr_…
+ * - https://max.ru/login/qr/<uuid> или :auth/<uuid>
+ * - web.max / trackId в query
+ * - «голый» UUID или строка qr_…
+ *
+ * @param {string} qrUrlOrTrackId
+ * @returns {string|null}
+ */
+function parseQrTrackId(qrUrlOrTrackId) {
+  const s = String(qrUrlOrTrackId == null ? '' : qrUrlOrTrackId).trim();
+  if (!s) return null;
+
+  let decoded = s;
+  try {
+    decoded = decodeURIComponent(s);
+  } catch (_) {
+    decoded = s;
+  }
+
+  const uuidRe = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  const qrTokenRe = /^qr_[a-zA-Z0-9_-]+$/i;
+
+  if (qrTokenRe.test(decoded)) {
+    return decoded;
+  }
+
+  try {
+    if (/^https?:\/\//i.test(decoded)) {
+      const u = new URL(decoded);
+      const tokenParam = u.searchParams.get('token');
+      if (tokenParam && qrTokenRe.test(tokenParam.trim())) {
+        return tokenParam.trim();
+      }
+      for (const key of ['trackId', 'track_id', 'track', 'tid']) {
+        const v = u.searchParams.get(key);
+        if (v) {
+          const m = String(v).match(uuidRe);
+          if (m) return m[0];
+        }
+      }
+      // https://max.ru/auth/<uuid> или max.ru/:auth/<uuid> (как в QR)
+      const pathSegs = u.pathname.split('/').filter(Boolean);
+      for (const seg of pathSegs) {
+        if (uuidRe.test(seg)) {
+          const m = seg.match(uuidRe);
+          if (m) return m[0];
+        }
+      }
+    }
+  } catch (_) {}
+
+  const m = decoded.match(uuidRe);
+  return m ? m[0] : null;
+}
+
+module.exports = { parseQrTrackId };

package/lib/session.js

@@ -40,6 +40,22 @@ class SessionManager {
     return false;
   }
 
+  /**
+   * Копия последнего успешного состояния (после удачного sync) — для ручного восстановления:
+   * скопируйте `.last_ok.json` на место основного файла сессии.
+   */
+  copyToLastOk() {
+    try {
+      if (!fs.existsSync(this.sessionFile)) return false;
+      const okPath = path.join(this.sessionDir, `${this.sessionName}.last_ok.json`);
+      fs.copyFileSync(this.sessionFile, okPath);
+      return true;
+    } catch (error) {
+      console.error('Ошибка резервной копии сессии:', error.message);
+      return false;
+    }
+  }
+
   /**
    * Сохраняет данные сессии в файл
    */

package/lib/socketTransport.js

@@ -6,8 +6,29 @@
 
 const tls = require('tls');
 const { encode: msgpackEncode, decode: msgpackDecode } = require('@msgpack/msgpack');
-const lz4Binding = require('lz4/lib/binding.js');
 const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Распаковка LZ4-блока (как в протоколе Max).
+ * Сначала нативный `lz4` (нужен node-gyp / VS C++ на Windows), иначе чистый JS `lz4js`.
+ */
+function resolveLz4Uncompress() {
+  try {
+    const lz4Binding = require('lz4/lib/binding.js');
+    return (inp, out) => lz4Binding.uncompress(inp, out);
+  } catch (_) {
+    try {
+      const lz4js = require('lz4js');
+      return (inp, out) => lz4js.decompressBlock(inp, out, 0, inp.length, 0);
+    } catch (e) {
+      throw new Error(
+        'LZ4: установите зависимость `lz4js` (npm i lz4js) или соберите нативный `lz4` (Visual Studio, C++ workload). ' +
+          e.message
+      );
+    }
+  }
+}
+const lz4Uncompress = resolveLz4Uncompress();
 const { Opcode, getOpcodeName } = require('./opcodes');
 const { UserAgentPayload } = require('./userAgent');
 
@@ -50,7 +71,7 @@ function unpackPacket(data) {
     try {
       if (compFlag !== 0) {
         const out = Buffer.alloc(Math.max(payloadLength * 20, 256 * 1024));
-        const n = lz4Binding.uncompress(payloadBytes, out);
+        const n = lz4Uncompress(payloadBytes, out);
         if (n > 0) payload = msgpackDecode(out.subarray(0, n));
       } else {
         payload = msgpackDecode(payloadBytes);
@@ -65,6 +86,7 @@ function unpackPacket(data) {
 
 /** JSON для логов: bigint → string, обрезка длинных строк */
 function safeJsonForLog(obj, maxLen = 12000) {
+  if (obj === undefined) return '(no payload)';
   try {
     const s = JSON.stringify(
       obj,
@@ -152,7 +174,8 @@ class MaxSocketTransport {
       cmd,
       seq: this.seq,
       opcode,
-      payload: payload || {}
+      // undefined — пустое тело пакета (как GET_QR без payload в web); null/{} — явный объект
+      payload: payload === undefined ? undefined : payload || {},
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webmaxsocket",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Node.js client for Max Messenger with QR code and token authentication",
   "main": "index.js",
   "scripts": {
@@ -38,7 +38,7 @@
   "homepage": "https://github.com/Tellarion/webmaxsocket#readme",
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3",
-    "lz4": "^0.6.5",
+    "lz4js": "^0.2.0",
     "qrcode-terminal": "^0.12.0",
     "uuid": "^9.0.0",
     "ws": "^8.18.0"