webmaxsocket 1.0.0 → 1.1.1

package/lib/opcodes.js

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

package/lib/socketTransport.js

@@ -0,0 +1,296 @@
+/**
+ * Socket transport для Max API (api.oneme.ru:443)
+ * Бинарный протокол msgpack с LZ4 компрессией
+ * Используется для IOS/DESKTOP/ANDROID устройств
+ */
+
+const tls = require('tls');
+const { encode: msgpackEncode, decode: msgpackDecode } = require('@msgpack/msgpack');
+const lz4Binding = require('lz4/lib/binding.js');
+const { v4: uuidv4 } = require('uuid');
+const { Opcode, getOpcodeName } = require('./opcodes');
+const { UserAgentPayload } = require('./userAgent');
+
+const HOST = 'api.oneme.ru';
+const PORT = 443;
+
+/**
+ * Формирует бинарный пакет
+ * Header: 1b ver, 2b cmd, 1b seq, 2b opcode, 4b payload_len
+ */
+function packPacket(ver, cmd, seq, opcode, payload) {
+  const payloadBuf = payload ? Buffer.from(msgpackEncode(payload)) : Buffer.alloc(0);
+  const payloadLen = payloadBuf.length & 0xFFFFFF;
+  const buf = Buffer.allocUnsafe(10 + payloadBuf.length);
+  buf.writeUInt8(ver, 0);
+  buf.writeUInt16BE(cmd, 1);
+  buf.writeUInt8(seq % 256, 3);
+  buf.writeUInt16BE(opcode, 4);
+  buf.writeUInt32BE(payloadLen, 6);
+  if (payloadBuf.length) payloadBuf.copy(buf, 10);
+  return buf;
+}
+
+/**
+ * Парсит ответ. compFlag: raw LZ4 block.
+ */
+function unpackPacket(data) {
+  if (data.length < 10) return null;
+  const ver = data.readUInt8(0);
+  const cmd = data.readUInt16BE(1);
+  const seq = data.readUInt8(3);
+  const opcode = data.readUInt16BE(4);
+  const packedLen = data.readUInt32BE(6);
+  const compFlag = packedLen >> 24;
+  const payloadLength = packedLen & 0xFFFFFF;
+  let payload = null;
+
+  if (payloadLength > 0 && data.length >= 10 + payloadLength) {
+    const payloadBytes = Buffer.from(data.subarray(10, 10 + payloadLength));
+    try {
+      if (compFlag !== 0) {
+        const out = Buffer.alloc(Math.max(payloadLength * 20, 256 * 1024));
+        const n = lz4Binding.uncompress(payloadBytes, out);
+        if (n > 0) payload = msgpackDecode(out.subarray(0, n));
+      } else {
+        payload = msgpackDecode(payloadBytes);
+      }
+    } catch (_) {
+      payload = null;
+    }
+  }
+
+  return { ver, cmd, seq, opcode, payload };
+}
+
+function readExactlyFromBuffer(transport, n) {
+  return new Promise((resolve) => {
+    const tryResolve = () => {
+      if (transport._recvBuffer.length >= n) {
+        const result = transport._recvBuffer.subarray(0, n);
+        transport._recvBuffer = transport._recvBuffer.subarray(n);
+        resolve(Buffer.from(result));
+        return true;
+      }
+      return false;
+    };
+    if (tryResolve()) return;
+
+    const onData = () => {
+      if (tryResolve()) transport.socket.removeListener('data', onData);
+    };
+    transport.socket.on('data', onData);
+  });
+}
+
+class MaxSocketTransport {
+  constructor(options = {}) {
+    this.host = options.host || HOST;
+    this.port = options.port || PORT;
+    this.deviceId = options.deviceId || uuidv4();
+    this.deviceType = options.deviceType || 'IOS';
+    this.ua = options.ua || options.headerUserAgent || 
+      'Mozilla/5.0 (iPhone15,2; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/602.1.50';
+    this.debug = options.debug || false;
+
+    this.socket = null;
+    this.seq = 0;
+    this.ver = 11;
+    this.pending = new Map();
+    this._recvBuffer = Buffer.alloc(0);
+  }
+
+  _log(...args) {
+    if (this.debug) console.log('[Socket]', ...args);
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      const opts = {
+        host: this.host,
+        port: this.port,
+        servername: this.host,
+        rejectUnauthorized: true
+      };
+      const sock = tls.connect(opts, () => {
+        this.socket = sock;
+        this._recvBuffer = Buffer.alloc(0);
+        sock.on('data', (chunk) => {
+          this._recvBuffer = Buffer.concat([this._recvBuffer, chunk]);
+        });
+        this._log('Connected to', this.host + ':' + this.port);
+        this._startRecvLoop();
+        resolve();
+      });
+      sock.on('error', reject);
+      sock.setKeepAlive(true);
+    });
+  }
+
+  _makeMessage(opcode, payload, cmd = 0) {
+    this.seq++;
+    return {
+      ver: this.ver,
+      cmd,
+      seq: this.seq,
+      opcode,
+      payload: payload || {}
+    };
+  }
+
+  _startRecvLoop() {
+    const readNext = async () => {
+      if (!this.socket || this.socket.destroyed) return;
+      try {
+        const header = await readExactlyFromBuffer(this, 10);
+        const packedLen = header.readUInt32BE(6);
+        const payloadLen = packedLen & 0xFFFFFF;
+        let payloadData = Buffer.alloc(0);
+        if (payloadLen > 0) {
+          payloadData = await readExactlyFromBuffer(this, payloadLen);
+        }
+        const packet = unpackPacket(Buffer.concat([header, payloadData]));
+        if (!packet) return readNext();
+
+        const seqKey = packet.seq % 256;
+        const payloads = Array.isArray(packet.payload) ? packet.payload : [packet.payload];
+        for (const p of payloads) {
+          const data = { ...packet, payload: p };
+          const pending = this.pending.get(seqKey);
+          if (pending) {
+            this.pending.delete(seqKey);
+            pending.resolve(data);
+            break;
+          }
+          if (this.onNotification) this.onNotification(data);
+        }
+      } catch (e) {
+        if (this.socket && !this.socket.destroyed) {
+          this._log('Recv error:', e.message);
+        }
+        for (const [, p] of this.pending) p.reject(e);
+        this.pending.clear();
+        return;
+      }
+      readNext();
+    };
+    readNext();
+  }
+
+  async sendAndWait(opcode, payload, cmd = 0, timeout = 20000) {
+    if (!this.socket || this.socket.destroyed) throw new Error('Socket not connected');
+
+    const msg = this._makeMessage(opcode, payload, cmd);
+    const seqKey = msg.seq % 256;
+    const packet = packPacket(msg.ver, msg.cmd, msg.seq, msg.opcode, msg.payload);
+
+    let pendingRef;
+    const promise = new Promise((resolve, reject) => {
+      const t = setTimeout(() => {
+        const p = this.pending.get(seqKey);
+        if (p) {
+          this.pending.delete(seqKey);
+          p.reject(new Error(`Timeout waiting for opcode ${getOpcodeName(opcode)}`));
+        }
+      }, timeout);
+      pendingRef = {
+        resolve: (data) => { clearTimeout(t); resolve(data); },
+        reject: (err) => { clearTimeout(t); reject(err); }
+      };
+      this.pending.set(seqKey, pendingRef);
+    });
+
+    this.socket.write(packet, (err) => {
+      if (err) {
+        const p = this.pending.get(seqKey);
+        if (p) {
+          this.pending.delete(seqKey);
+          p.reject(err);
+        }
+      }
+    });
+
+    const result = await promise;
+    if (result.payload && result.payload.error) {
+      const errMsg = result.payload.localizedMessage || result.payload.error?.message || JSON.stringify(result.payload.error);
+      throw new Error(errMsg);
+    }
+    return result;
+  }
+
+  async handshake(userAgentPayload) {
+    const ua = userAgentPayload || new UserAgentPayload({
+      deviceType: this.deviceType,
+      headerUserAgent: this.ua,
+      appVersion: '25.12.14',
+      osVersion: '18.6.2',
+      deviceName: 'Safari',
+      screen: '390x844 3.0x'
+    });
+    const payload = {
+      deviceId: this.deviceId,
+      userAgent: typeof ua.toJSON === 'function' ? ua.toJSON() : ua
+    };
+    const resp = await this.sendAndWait(Opcode.SESSION_INIT, payload);
+    this._log('Handshake OK');
+    return resp;
+  }
+
+  async requestCode(phone, language = 'ru') {
+    const payload = { phone, type: 'START_AUTH', language };
+    const data = await this.sendAndWait(Opcode.AUTH_REQUEST, payload);
+    return data.payload?.token || null;
+  }
+
+  async sendCode(tempToken, code) {
+    const payload = {
+      token: tempToken,
+      verifyCode: code,
+      authTokenType: 'CHECK_CODE'
+    };
+    const data = await this.sendAndWait(Opcode.AUTH, payload);
+    return data.payload;
+  }
+
+  async sync(token, userAgentJson) {
+    const payload = {
+      interactive: true,
+      token,
+      chatsSync: 0,
+      contactsSync: 0,
+      presenceSync: 0,
+      draftsSync: 0,
+      chatsCount: 40
+    };
+    if (userAgentJson) payload.userAgent = userAgentJson;
+    const data = await this.sendAndWait(Opcode.LOGIN, payload);
+    return data.payload;
+  }
+
+  async getChats(marker = 0) {
+    const data = await this.sendAndWait(Opcode.CHATS_LIST, { marker });
+    return data.payload?.chats || [];
+  }
+
+  async getHistory(chatId, from = Date.now(), backward = 200, forward = 0) {
+    const data = await this.sendAndWait(Opcode.CHAT_HISTORY, {
+      chatId,
+      from,
+      forward,
+      backward,
+      getMessages: true
+    });
+    return data.payload?.messages || [];
+  }
+
+  async close() {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+    for (const [, p] of this.pending) p.reject(new Error('Connection closed'));
+    this.pending.clear();
+  }
+}
+
+module.exports = { MaxSocketTransport, packPacket, unpackPacket, HOST, PORT };

package/lib/userAgent.js

@@ -42,10 +42,11 @@ function randomInt(min, max) {
 
 /**
  * Создает UserAgent пейлоад для Max API
+ * Поддерживает WEB, IOS и кастомные профили (для token auth)
  */
 class UserAgentPayload {
   constructor(options = {}) {
-    this.deviceType = 'WEB'; // Всегда WEB (только QR авторизация)
+    this.deviceType = options.deviceType || 'WEB';
     this.locale = options.locale || 'ru';
     this.deviceLocale = options.deviceLocale || 'ru';
     this.osVersion = options.osVersion || randomChoice(OS_VERSIONS);
@@ -54,15 +55,16 @@ class UserAgentPayload {
     this.appVersion = options.appVersion || '25.12.14';
     this.screen = options.screen || randomChoice(SCREEN_SIZES);
     this.timezone = options.timezone || randomChoice(TIMEZONES);
-    this.clientSessionId = options.clientSessionId || randomInt(1, 15);
-    this.buildNumber = options.buildNumber || 0x97CB; // 38859
+    this.clientSessionId = options.clientSessionId ?? randomInt(1, 15);
+    this.buildNumber = options.buildNumber ?? 0x97CB;
+    this.release = options.release;
   }
 
   /**
    * Преобразует в объект для отправки (camelCase ключи)
    */
   toJSON() {
-    return {
+    const obj = {
       deviceType: this.deviceType,
       locale: this.locale,
       deviceLocale: this.deviceLocale,
@@ -75,6 +77,8 @@ class UserAgentPayload {
       clientSessionId: this.clientSessionId,
       buildNumber: this.buildNumber,
     };
+    if (this.release !== undefined) obj.release = this.release;
+    return obj;
   }
 }
 

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "webmaxsocket",
-  "version": "1.0.0",
-  "description": "Node.js client for Max Messenger with QR code authentication",
+  "version": "1.1.1",
+  "description": "Node.js client for Max Messenger with QR code and token authentication",
   "main": "index.js",
   "scripts": {
     "start": "node example.js",
-    "example": "node example.js"
+    "example": "node example.js",
+    "example:token": "node example-token.js",
+    "example:sms": "node example-sms.js",
+    "example:ios": "node example-ios.js"
   },
   "keywords": [
     "max",
@@ -18,6 +21,7 @@
     "websocket",
     "qr-code",
     "qr-auth",
+    "token-auth",
     "bot",
     "nodejs",
     "commonjs"
@@ -33,18 +37,27 @@
   },
   "homepage": "https://github.com/Tellarion/webmaxsocket#readme",
   "dependencies": {
+    "@msgpack/msgpack": "^3.1.3",
+    "lz4": "^0.6.5",
     "qrcode-terminal": "^0.12.0",
     "uuid": "^9.0.0",
     "ws": "^8.18.0"
   },
+  "optionalDependencies": {
+    "lz4": "^0.6.5"
+  },
   "devDependencies": {},
   "engines": {
     "node": ">=14.0.0"
   },
   "files": [
     "lib/",
+    "config/",
     "index.js",
     "example.js",
+    "example-token.js",
+    "example-sms.js",
+    "example-ios.js",
     "README.md"
   ]
 }