webmaxsocket 1.1.3 → 1.1.5

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;
@@ -154,6 +171,9 @@ class WebMaxClient extends EventEmitter {
     this._wireIncomingLogListeners();
     /** client id локальных исходящих сообщений (int32, часто ждут валидацию на сервере) */
     this._clientSendCid = 1 + Math.floor(Math.random() * 0xfffff);
+    /** После HTTP POST видео/файла — ждём NOTIF_ATTACH */
+    this._uploadPendingVideo = new Map();
+    this._uploadPendingFile = new Map();
   }
 
   /**
@@ -313,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);
 
@@ -333,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-кода
    */
@@ -406,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);
 
@@ -468,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;
@@ -837,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
@@ -869,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) {
@@ -939,6 +1400,10 @@ class WebMaxClient extends EventEmitter {
           }
           break;
 
+        case Opcode.NOTIF_ATTACH:
+          this._handleNotifAttach(data.payload);
+          break;
+
         default:
           this.emit('raw_message', data);
       }
@@ -952,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);
@@ -976,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);
         
@@ -1006,7 +1478,11 @@ class WebMaxClient extends EventEmitter {
         case Opcode.PING:
           await this.sendPong();
           break;
-          
+
+        case Opcode.NOTIF_ATTACH:
+          this._handleNotifAttach(message.payload);
+          break;
+
         default:
           this.emit('raw_message', message);
       }
@@ -1079,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;
   }
 
   /**
@@ -1192,6 +1672,73 @@ class WebMaxClient extends EventEmitter {
     return Number.isNaN(n) ? chatId : n;
   }
 
+  /**
+   * NOTIF_ATTACH (136): готовность вложения после загрузки видео/файла.
+   */
+  _handleNotifAttach(payload) {
+    if (!payload || typeof payload !== 'object') return;
+    const vid = payload.videoId;
+    if (vid != null) {
+      const k = String(vid);
+      const fn = this._uploadPendingVideo.get(k);
+      if (fn) {
+        this._uploadPendingVideo.delete(k);
+        fn();
+      }
+    }
+    const fid = payload.fileId;
+    if (fid != null) {
+      const k = String(fid);
+      const fn = this._uploadPendingFile.get(k);
+      if (fn) {
+        this._uploadPendingFile.delete(k);
+        fn();
+      }
+    }
+  }
+
+  /**
+   * @param {Map<string, function(): void>} map
+   */
+  _waitUploadNotif(map, id, label, timeoutMs = 120000) {
+    return new Promise((resolve, reject) => {
+      const k = String(id);
+      const t = setTimeout(() => {
+        map.delete(k);
+        reject(new Error(`Таймаут ожидания NOTIF_ATTACH (${label})`));
+      }, timeoutMs);
+      map.set(k, () => {
+        clearTimeout(t);
+        resolve();
+      });
+    });
+  }
+
+  async _postMultipartUpload(uploadUrl, buf, fname, mime) {
+    const { Blob } = require('buffer');
+    if (typeof fetch !== 'function') {
+      throw new Error('upload: нужен Node.js 18+ с глобальным fetch');
+    }
+    const form = new FormData();
+    form.append('file', new Blob([buf], { type: mime }), fname);
+    const res = await fetch(uploadUrl, {
+      method: 'POST',
+      body: form,
+      headers: {
+        Accept: '*/*',
+        'Accept-Language': 'ru-RU,ru;q=0.9',
+        Origin: 'https://web.max.ru',
+        Referer: 'https://web.max.ru/',
+        'User-Agent': this.userAgent.headerUserAgent || 'Mozilla/5.0'
+      }
+    });
+    if (!res.ok) {
+      const t = await res.text();
+      throw new Error(`HTTP загрузка: ${res.status} ${t.slice(0, 300)}`);
+    }
+    return res;
+  }
+
   /**
    * Отправка сообщения (с уведомлением)
    */
@@ -1242,18 +1789,218 @@ class WebMaxClient extends EventEmitter {
     return response.payload;
   }
 
+  /**
+   * Загрузка локального изображения на сервер Max; результат передать в `attachments` у sendMessage / reply.
+   * Схема: PHOTO_UPLOAD → UPLOAD_ATTACH_PREP → HTTP POST на выданный URL. Нужен Node 18+ (fetch, FormData).
+   *
+   * @param {number|string|bigint} chatId
+   * @param {string} filePath путь к файлу (.png, .jpg, …)
+   * @returns {Promise<{ _type: 'PHOTO', photoToken: string }>}
+   */
+  async uploadPhoto(chatId, filePath) {
+    const fsp = require('fs/promises');
+    const path = require('path');
+
+    const buf = await fsp.readFile(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    const mime =
+      ext === '.png'
+        ? 'image/png'
+        : ext === '.webp'
+          ? 'image/webp'
+          : ext === '.gif'
+            ? 'image/gif'
+            : 'image/jpeg';
+    const fname = path.basename(filePath) || 'image.jpg';
+
+    const r1 = await this.sendAndWait(Opcode.PHOTO_UPLOAD, { count: 1 });
+    const p1 = r1.payload;
+    if (p1 && p1.error) {
+      const e = new Error(
+        typeof p1.error === 'string' ? p1.error : JSON.stringify(p1.error)
+      );
+      e.rawPayload = p1;
+      throw e;
+    }
+    const uploadUrl = p1 && p1.url;
+    if (!uploadUrl) {
+      throw new Error('PHOTO_UPLOAD: нет url в ответе');
+    }
+
+    await this.sendAndWait(Opcode.UPLOAD_ATTACH_PREP, {
+      chatId: this._normalizeChatId(chatId),
+      type: 'PHOTO'
+    });
+
+    const res = await this._postMultipartUpload(uploadUrl, buf, fname, mime);
+    const obj = await res.json();
+    const photos = obj.photos;
+    let first;
+    if (Array.isArray(photos)) {
+      [first] = photos;
+    } else if (photos && typeof photos === 'object') {
+      first = Object.values(photos)[0];
+    }
+    const token = first && first.token;
+    if (!token) {
+      throw new Error(`PHOTO upload: неожиданный JSON: ${JSON.stringify(obj).slice(0, 400)}`);
+    }
+
+    return {
+      _type: 'PHOTO',
+      photoToken: token
+    };
+  }
+
+  /**
+   * Загрузка видео; результат для `attachments: [{ _type: 'VIDEO', videoId, token }]`.
+   * После HTTP POST ждёт NOTIF_ATTACH (opcode 136).
+   */
+  async uploadVideo(chatId, filePath) {
+    const fsp = require('fs/promises');
+    const path = require('path');
+
+    const buf = await fsp.readFile(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    const fname = path.basename(filePath) || 'video.mp4';
+    const mime =
+      ext === '.webm' ? 'video/webm' : ext === '.mov' ? 'video/quicktime' : 'video/mp4';
+
+    const r = await this.sendAndWait(Opcode.VIDEO_UPLOAD, { count: 1 });
+    const p = r.payload;
+    if (p && p.error) {
+      const e = new Error(
+        typeof p.error === 'string' ? p.error : JSON.stringify(p.error)
+      );
+      e.rawPayload = p;
+      throw e;
+    }
+    const info = p && p.info && p.info[0];
+    if (!info) {
+      throw new Error('VIDEO_UPLOAD: нет info в ответе');
+    }
+    const { url: uploadUrl, videoId, token } = info;
+    if (!uploadUrl || videoId == null || token == null) {
+      throw new Error('VIDEO_UPLOAD: нет url, videoId или token');
+    }
+
+    const waitReady = this._waitUploadNotif(this._uploadPendingVideo, videoId, 'VIDEO');
+
+    await this.sendAndWait(Opcode.UPLOAD_ATTACH_PREP, {
+      chatId: this._normalizeChatId(chatId),
+      type: 'VIDEO'
+    });
+
+    await this._postMultipartUpload(uploadUrl, buf, fname, mime);
+
+    await waitReady;
+
+    return { _type: 'VIDEO', videoId, token };
+  }
+
+  /**
+   * Загрузка произвольного файла (документ, архив, **аудио** и т.д.) для `attachments: [{ _type: 'FILE', fileId }]`.
+   * После HTTP POST ждёт NOTIF_ATTACH.
+   *
+   * @param {{ filename?: string, mimeType?: string }} [options]
+   */
+  async uploadFile(chatId, filePath, options = {}) {
+    const fsp = require('fs/promises');
+    const path = require('path');
+
+    const buf = await fsp.readFile(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    const fname = options.filename || path.basename(filePath) || 'file.bin';
+    const mime =
+      options.mimeType ||
+      this._mimeGuessForFile(ext);
+
+    const r = await this.sendAndWait(Opcode.FILE_UPLOAD, { count: 1 });
+    const p = r.payload;
+    if (p && p.error) {
+      const e = new Error(
+        typeof p.error === 'string' ? p.error : JSON.stringify(p.error)
+      );
+      e.rawPayload = p;
+      throw e;
+    }
+    const info = p && p.info && p.info[0];
+    if (!info) {
+      throw new Error('FILE_UPLOAD: нет info в ответе');
+    }
+    const { url: uploadUrl, fileId } = info;
+    if (!uploadUrl || fileId == null) {
+      throw new Error('FILE_UPLOAD: нет url или fileId');
+    }
+
+    const waitReady = this._waitUploadNotif(this._uploadPendingFile, fileId, 'FILE');
+
+    await this.sendAndWait(Opcode.UPLOAD_ATTACH_PREP, {
+      chatId: this._normalizeChatId(chatId),
+      type: 'FILE'
+    });
+
+    await this._postMultipartUpload(uploadUrl, buf, fname, mime);
+
+    await waitReady;
+
+    return { _type: 'FILE', fileId };
+  }
+
+  /**
+   * Загрузка аудио как файла (удобно для .mp3, .ogg, .m4a, .wav).
+   * Внутри вызывает uploadFile() с подходящим MIME.
+   */
+  async uploadAudio(chatId, filePath) {
+    const path = require('path');
+    const ext = path.extname(filePath).toLowerCase();
+    const mime =
+      ext === '.mp3'
+        ? 'audio/mpeg'
+        : ext === '.ogg' || ext === '.oga'
+          ? 'audio/ogg'
+          : ext === '.m4a' || ext === '.aac'
+            ? 'audio/mp4'
+            : ext === '.wav'
+              ? 'audio/wav'
+              : ext === '.flac'
+                ? 'audio/flac'
+                : 'audio/mpeg';
+    return this.uploadFile(chatId, filePath, { mimeType: mime });
+  }
+
+  _mimeGuessForFile(ext) {
+    const m = {
+      '.png': 'image/png',
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.gif': 'image/gif',
+      '.webp': 'image/webp',
+      '.pdf': 'application/pdf',
+      '.zip': 'application/zip',
+      '.mp3': 'audio/mpeg',
+      '.ogg': 'audio/ogg',
+      '.m4a': 'audio/mp4',
+      '.wav': 'audio/wav',
+      '.flac': 'audio/flac',
+      '.mp4': 'video/mp4',
+      '.webm': 'video/webm'
+    };
+    return m[ext] || 'application/octet-stream';
+  }
+
   /**
    * Редактирование сообщения
    */
   async editMessage(options) {
-    const { messageId, chatId, text } = options;
+    const { messageId, chatId, text, attachments } = options;
 
     const payload = {
       chatId: chatId,
       messageId: messageId,
       text: text || '',
       elements: [],
-      attaches: []
+      attaches: Array.isArray(attachments) && attachments.length ? attachments : []
     };
 
     const response = await this.sendAndWait(Opcode.MSG_EDIT, payload);
@@ -1354,6 +2101,360 @@ class WebMaxClient extends EventEmitter {
     return messages.map(msg => new Message(msg, this));
   }
 
+  /**
+   * Закрепить сообщение в чате (CHAT_UPDATE).
+   */
+  async pinMessage({ chatId, messageId, notifyPin = false }) {
+    return await this.sendAndWait(Opcode.CHAT_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      messageId: String(messageId),
+      notifyPin: !!notifyPin
+    });
+  }
+
+  /**
+   * Поставить реакцию-эмодзи на сообщение.
+   */
+  async setMessageReaction({ chatId, messageId, emoji }) {
+    return await this.sendAndWait(Opcode.MSG_REACTION, {
+      chatId: this._normalizeChatId(chatId),
+      messageId: String(messageId),
+      reaction: {
+        reactionType: 'EMOJI',
+        id: String(emoji)
+      }
+    });
+  }
+
+  /**
+   * Снять свою реакцию с сообщения.
+   */
+  async cancelMessageReaction({ chatId, messageId }) {
+    return await this.sendAndWait(Opcode.MSG_CANCEL_REACTION, {
+      chatId: this._normalizeChatId(chatId),
+      messageId: String(messageId)
+    });
+  }
+
+  /**
+   * Список реакций на сообщение.
+   */
+  async getMessageReactions({ chatId, messageId, count = 100 }) {
+    return await this.sendAndWait(Opcode.MSG_GET_REACTIONS, {
+      chatId: this._normalizeChatId(chatId),
+      messageId: String(messageId),
+      count
+    });
+  }
+
+  /**
+   * Информация о чатах по id (opcode 48).
+   */
+  async getChatInfo(chatIds) {
+    const ids = Array.isArray(chatIds) ? chatIds : [chatIds];
+    const response = await this.sendAndWait(Opcode.CHAT_INFO, { chatIds: ids });
+    return response.payload;
+  }
+
+  /**
+   * Разрешить ссылку: канал, инвайт join/…, URL max.ru (LINK_INFO).
+   */
+  async resolveLink(link) {
+    const response = await this.sendAndWait(Opcode.LINK_INFO, { link: String(link) });
+    return response.payload;
+  }
+
+  /**
+   * Вступить по ссылке (канал, группа и т.д.).
+   */
+  async joinChatByLink(link) {
+    const response = await this.sendAndWait(Opcode.CHAT_JOIN, { link: String(link) });
+    return response.payload;
+  }
+
+  /**
+   * Подписка / отписка на канал.
+   */
+  async setChatSubscription(chatId, subscribe) {
+    return await this.sendAndWait(Opcode.CHAT_SUBSCRIBE, {
+      chatId: this._normalizeChatId(chatId),
+      subscribe: !!subscribe
+    });
+  }
+
+  /**
+   * Создать групповой чат (CONTROL в MSG_SEND).
+   */
+  async createGroup({ title, userIds }) {
+    const cid = this._nextClientMessageId();
+    return await this.sendAndWait(Opcode.MSG_SEND, {
+      message: {
+        text: '',
+        cid,
+        elements: [],
+        attaches: [
+          {
+            _type: 'CONTROL',
+            event: 'new',
+            chatType: 'CHAT',
+            title,
+            userIds
+          }
+        ]
+      },
+      notify: true
+    });
+  }
+
+  /**
+   * Создать канал (CONTROL в MSG_SEND).
+   */
+  async createChannel({ title }) {
+    const cid = this._nextClientMessageId();
+    return await this.sendAndWait(Opcode.MSG_SEND, {
+      message: {
+        text: '',
+        cid,
+        elements: [],
+        attaches: [
+          {
+            _type: 'CONTROL',
+            event: 'new',
+            title,
+            chatType: 'CHANNEL'
+          }
+        ]
+      },
+      notify: true
+    });
+  }
+
+  /**
+   * Отключить уведомления в чате (CONFIG), как «не беспокоить» для чата.
+   */
+  async muteChat(chatId, mute = true) {
+    const id = String(this._normalizeChatId(chatId));
+    return await this.sendAndWait(Opcode.CONFIG, {
+      settings: {
+        chats: {
+          [id]: {
+            dontDisturbUntil: mute ? -1 : 0
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Участники чата (не более 500 за запрос).
+   */
+  async getChatMembers({ chatId, marker = 0, count = 500, type = 'MEMBER' }) {
+    if (count > 500) {
+      throw new Error('getChatMembers: count не больше 500');
+    }
+    return await this.sendAndWait(Opcode.CHAT_MEMBERS, {
+      type,
+      marker,
+      chatId: this._normalizeChatId(chatId),
+      count
+    });
+  }
+
+  /**
+   * Пригласить пользователей в чат.
+   */
+  async inviteToChat({ chatId, userIds, showHistory = true }) {
+    return await this.sendAndWait(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      userIds,
+      showHistory,
+      operation: 'add'
+    });
+  }
+
+  /**
+   * Исключить пользователей из чата.
+   */
+  async removeFromChat({ chatId, userIds, cleanMsgPeriod = 0 }) {
+    return await this.sendAndWait(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      userIds,
+      operation: 'remove',
+      cleanMsgPeriod
+    });
+  }
+
+  /**
+   * Назначить администраторов. `permissions` — битовая маска прав (по умолчанию 120).
+   */
+  async addChatAdmins({ chatId, userIds, permissions = 120 }) {
+    return await this.sendAndWait(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      userIds,
+      type: 'ADMIN',
+      operation: 'add',
+      permissions
+    });
+  }
+
+  /**
+   * Снять права администратора.
+   */
+  async removeChatAdmins({ chatId, userIds }) {
+    return await this.sendAndWait(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      userIds,
+      type: 'ADMIN',
+      operation: 'remove'
+    });
+  }
+
+  /**
+   * Передать владение группой.
+   */
+  async transferChatOwnership({ chatId, newOwnerId }) {
+    return await this.sendAndWait(Opcode.CHAT_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      changeOwnerId: newOwnerId
+    });
+  }
+
+  /**
+   * Настройки группы: например ONLY_OWNER_CAN_CHANGE_ICON_TITLE, ALL_CAN_PIN_MESSAGE, ONLY_ADMIN_CAN_ADD_MEMBER.
+   */
+  async setGroupOptions({ chatId, options }) {
+    return await this.sendAndWait(Opcode.CHAT_UPDATE, {
+      chatId: this._normalizeChatId(chatId),
+      options
+    });
+  }
+
+  /**
+   * Несколько контактов по id (сырой ответ CONTACT_INFO).
+   */
+  async getContacts(contactIds) {
+    const ids = Array.isArray(contactIds) ? contactIds : [contactIds];
+    const response = await this.sendAndWait(Opcode.CONTACT_INFO, { contactIds: ids });
+    return response.payload;
+  }
+
+  /**
+   * Добавить пользователя в контакты.
+   */
+  async addContact(userId) {
+    return await this.sendAndWait(Opcode.CONTACT_UPDATE, {
+      contactId: userId,
+      action: 'ADD'
+    });
+  }
+
+  /**
+   * Заблокировать пользователя.
+   */
+  async blockUser(userId) {
+    return await this.sendAndWait(Opcode.CONTACT_UPDATE, {
+      contactId: userId,
+      action: 'BLOCK'
+    });
+  }
+
+  /**
+   * Изменить своё имя / описание (PROFILE).
+   */
+  async updateProfile({ firstName, lastName, description } = {}) {
+    const payload = {};
+    if (firstName !== undefined) payload.firstName = firstName;
+    if (lastName !== undefined) payload.lastName = lastName;
+    if (description !== undefined) payload.description = description;
+    return await this.sendAndWait(Opcode.PROFILE, payload);
+  }
+
+  /**
+   * Скрыть статус «в сети» для других.
+   */
+  async setHiddenOnline(hidden) {
+    return await this.sendAndWait(Opcode.CONFIG, {
+      settings: {
+        user: { HIDDEN: !!hidden }
+      }
+    });
+  }
+
+  /**
+   * Кто может найти вас по телефону: 'ALL' | 'CONTACTS' или true/false (как ALL/CONTACTS).
+   */
+  async setFindableByPhone(mode) {
+    const v =
+      mode === true || mode === 'ALL'
+        ? 'ALL'
+        : mode === false || mode === 'CONTACTS'
+          ? 'CONTACTS'
+          : String(mode);
+    return await this.sendAndWait(Opcode.CONFIG, {
+      settings: {
+        user: { SEARCH_BY_PHONE: v }
+      }
+    });
+  }
+
+  /**
+   * Кто может звонить: 'ALL' | 'CONTACTS'.
+   */
+  async setCallsPrivacyMode(mode) {
+    const v =
+      mode === true || mode === 'ALL'
+        ? 'ALL'
+        : mode === false || mode === 'CONTACTS'
+          ? 'CONTACTS'
+          : String(mode);
+    return await this.sendAndWait(Opcode.CONFIG, {
+      settings: {
+        user: { INCOMING_CALL: v }
+      }
+    });
+  }
+
+  /**
+   * Кто может приглашать вас в чаты: 'ALL' | 'CONTACTS'.
+   */
+  async setChatsInvitePrivacy(mode) {
+    const v =
+      mode === true || mode === 'ALL'
+        ? 'ALL'
+        : mode === false || mode === 'CONTACTS'
+          ? 'CONTACTS'
+          : String(mode);
+    return await this.sendAndWait(Opcode.CONFIG, {
+      settings: {
+        user: { CHATS_INVITE: v }
+      }
+    });
+  }
+
+  /**
+   * Удобно: канал по @username (resolveLink на https://max.ru/username).
+   */
+  async resolveChannelByUsername(username) {
+    const u = String(username).replace(/^@/, '');
+    return this.resolveLink(`https://max.ru/${u}`);
+  }
+
+  /**
+   * Вступить в канал по @username.
+   */
+  async joinChannelByUsername(username) {
+    const u = String(username).replace(/^@/, '');
+    return this.joinChatByLink(`https://max.ru/${u}`);
+  }
+
+  /**
+   * Инвайт по хэшу из ссылки join/XXXX.
+   */
+  async resolveInviteHash(hash) {
+    const h = String(hash).replace(/^join\//, '');
+    return this.resolveLink(`join/${h}`);
+  }
+
   /**
    * Выполнение зарегистрированных обработчиков
    */