webmaxsocket 1.1.4 → 1.1.5

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 }
@@ -79,34 +80,50 @@ class WebMaxClient extends EventEmitter {
     
     this._providedToken = token;
     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 +144,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;
@@ -316,7 +333,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 +353,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 +863,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 +925,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;
@@ -840,9 +1294,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 +1329,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 +1417,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 +1444,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 +1555,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/socketTransport.js

@@ -65,6 +65,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 +153,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.5",
   "description": "Node.js client for Max Messenger with QR code and token authentication",
   "main": "index.js",
   "scripts": {