@skyzopedia/baileys-mod 3.0.2

package/lib/WAM/encode.js

@@ -0,0 +1,154 @@
+//=======================================================//
+import { FLAG_BYTE, FLAG_EVENT, FLAG_EXTENDED, FLAG_FIELD, FLAG_GLOBAL, WEB_EVENTS, WEB_GLOBALS } from "./constants.js";
+import { BinaryInfo } from "./BinaryInfo.js";
+//=======================================================//
+const getHeaderBitLength = (key) => (key < 256 ? 2 : 3);
+export const encodeWAM = (binaryInfo) => {
+  binaryInfo.buffer = [];
+  encodeWAMHeader(binaryInfo);
+  encodeEvents(binaryInfo);
+  const totalSize = binaryInfo.buffer.map(a => a.length).reduce((a, b) => a + b);
+  const buffer = Buffer.alloc(totalSize);
+  let offset = 0;
+  for (const buffer_ of binaryInfo.buffer) {
+    buffer_.copy(buffer, offset);
+    offset += buffer_.length;
+  }
+  return buffer;
+};
+//=======================================================//
+function encodeWAMHeader(binaryInfo) {
+  const headerBuffer = Buffer.alloc(8);
+  headerBuffer.write("WAM", 0, "utf8");
+  headerBuffer.writeUInt8(binaryInfo.protocolVersion, 3);
+  headerBuffer.writeUInt8(1, 4);
+  headerBuffer.writeUInt16BE(binaryInfo.sequence, 5);
+  headerBuffer.writeUInt8(0, 7);
+  binaryInfo.buffer.push(headerBuffer);
+}
+//=======================================================//
+function encodeGlobalAttributes(binaryInfo, globals) {
+  for (const [key, _value] of Object.entries(globals)) {
+    const id = WEB_GLOBALS.find(a => a?.name === key).id;
+    let value = _value;
+    if (typeof value === "boolean") {
+      value = value ? 1 : 0;
+    }
+    binaryInfo.buffer.push(serializeData(id, value, FLAG_GLOBAL));
+  }
+}
+//=======================================================//
+function encodeEvents(binaryInfo) {
+  for (const [name, { props, globals }] of binaryInfo.events.map(a => Object.entries(a)[0])) {
+    encodeGlobalAttributes(binaryInfo, globals);
+    const event = WEB_EVENTS.find(a => a.name === name);
+    const props_ = Object.entries(props);
+    let extended = false;
+    for (const [, value] of props_) {
+      extended || (extended = value !== null);
+    }
+    const eventFlag = extended ? FLAG_EVENT : FLAG_EVENT | FLAG_EXTENDED;
+    binaryInfo.buffer.push(serializeData(event.id, -event.weight, eventFlag));
+    for (let i = 0; i < props_.length; i++) {
+      const [key, _value] = props_[i];
+      const id = event.props[key]?.[0];
+      extended = i < props_.length - 1;
+      let value = _value;
+      if (typeof value === "boolean") {
+        value = value ? 1 : 0;
+      }
+      const fieldFlag = extended ? FLAG_EVENT : FLAG_FIELD | FLAG_EXTENDED;
+      binaryInfo.buffer.push(serializeData(id, value, fieldFlag));
+    }
+  }
+}
+//=======================================================//
+function serializeData(key, value, flag) {
+  const bufferLength = getHeaderBitLength(key);
+  let buffer;
+  let offset = 0;
+  if (value === null) {
+    if (flag === FLAG_GLOBAL) {
+      buffer = Buffer.alloc(bufferLength);
+      offset = serializeHeader(buffer, offset, key, flag);
+      return buffer;
+    }
+  }
+  else if (typeof value === "number" && Number.isInteger(value)) {
+    if (value === 0 || value === 1) {
+      buffer = Buffer.alloc(bufferLength);
+      offset = serializeHeader(buffer, offset, key, flag | ((value + 1) << 4));
+      return buffer;
+    }
+    else if (-128 <= value && value < 128) {
+      buffer = Buffer.alloc(bufferLength + 1);
+      offset = serializeHeader(buffer, offset, key, flag | (3 << 4));
+      buffer.writeInt8(value, offset);
+      return buffer;
+    }
+    else if (-32768 <= value && value < 32768) {
+      buffer = Buffer.alloc(bufferLength + 2);
+      offset = serializeHeader(buffer, offset, key, flag | (4 << 4));
+      buffer.writeInt16LE(value, offset);
+      return buffer;
+    }
+    else if (-2147483648 <= value && value < 2147483648) {
+      buffer = Buffer.alloc(bufferLength + 4);
+      offset = serializeHeader(buffer, offset, key, flag | (5 << 4));
+      buffer.writeInt32LE(value, offset);
+      return buffer;
+    }
+    else {
+      buffer = Buffer.alloc(bufferLength + 8);
+      offset = serializeHeader(buffer, offset, key, flag | (7 << 4));
+      buffer.writeDoubleLE(value, offset);
+      return buffer;
+    }
+  }
+  else if (typeof value === "number") {
+    buffer = Buffer.alloc(bufferLength + 8);
+    offset = serializeHeader(buffer, offset, key, flag | (7 << 4));
+    buffer.writeDoubleLE(value, offset);
+    return buffer;
+  }
+  else if (typeof value === "string") {
+    const utf8Bytes = Buffer.byteLength(value, "utf8");
+    if (utf8Bytes < 256) {
+      buffer = Buffer.alloc(bufferLength + 1 + utf8Bytes);
+      offset = serializeHeader(buffer, offset, key, flag | (8 << 4));
+      buffer.writeUint8(utf8Bytes, offset++);
+    }
+    else if (utf8Bytes < 65536) {
+      buffer = Buffer.alloc(bufferLength + 2 + utf8Bytes);
+      offset = serializeHeader(buffer, offset, key, flag | (9 << 4));
+      buffer.writeUInt16LE(utf8Bytes, offset);
+      offset += 2;
+    }
+    else {
+      buffer = Buffer.alloc(bufferLength + 4 + utf8Bytes);
+      offset = serializeHeader(buffer, offset, key, flag | (10 << 4));
+      buffer.writeUInt32LE(utf8Bytes, offset);
+      offset += 4;
+    }
+    buffer.write(value, offset, "utf8");
+    return buffer;
+  }
+  throw "missing";
+}
+//=======================================================//
+function serializeHeader(buffer, offset, key, flag) {
+  if (key < 256) {
+    buffer.writeUInt8(flag, offset);
+    offset += 1;
+    buffer.writeUInt8(key, offset);
+    offset += 1;
+  }
+  else {
+    buffer.writeUInt8(flag | FLAG_BYTE, offset);
+    offset += 1;
+    buffer.writeUInt16LE(key, offset);
+    offset += 2;
+  }
+  return offset;
+}
+//=======================================================//

package/lib/WAM/index.js

@@ -0,0 +1,5 @@
+//=======================================================//
+export * from "./BinaryInfo.js";
+export * from "./constants.js";
+export * from "./encode.js";
+//=======================================================//

package/lib/WAUSync/Protocols/USyncContactProtocol.js

@@ -0,0 +1,30 @@
+//=======================================================//
+import { assertNodeErrorFree } from "../../WABinary/index.js";
+import { USyncUser } from "../USyncUser.js";
+//=======================================================//
+export class USyncContactProtocol {
+  constructor() {
+    this.name = "contact";
+  }
+  getQueryElement() {
+    return {
+      tag: "contact",
+      attrs: {}
+    };
+  }
+  getUserElement(user) {
+    return {
+      tag: "contact",
+      attrs: {},
+      content: user.phone
+    };
+  }
+  parser(node) {
+    if (node.tag === "contact") {
+      assertNodeErrorFree(node);
+      return node?.attrs?.type === "in";
+    }
+    return false;
+  }
+}
+//=======================================================//

package/lib/WAUSync/Protocols/USyncDeviceProtocol.js

@@ -0,0 +1,53 @@
+//=======================================================//
+import { assertNodeErrorFree, getBinaryNodeChild } from "../../WABinary/index.js";
+//=======================================================//
+export class USyncDeviceProtocol {
+  constructor() {
+    this.name = "devices";
+  }
+  getQueryElement() {
+    return {
+      tag: "devices",
+      attrs: {
+        version: "2"
+      }
+    };
+  }
+  getUserElement() {
+    return null;
+  }
+  parser(node) {
+    const deviceList = [];
+    let keyIndex = undefined;
+    if (node.tag === "devices") {
+      assertNodeErrorFree(node);
+      const deviceListNode = getBinaryNodeChild(node, "device-list");
+      const keyIndexNode = getBinaryNodeChild(node, "key-index-list");
+      if (Array.isArray(deviceListNode?.content)) {
+        for (const { tag, attrs } of deviceListNode.content) {
+          const id = +attrs.id;
+          const keyIndex = +attrs["key-index"];
+          if (tag === "device") {
+            deviceList.push({
+              id,
+              keyIndex,
+              isHosted: !!(attrs["is_hosted"] && attrs["is_hosted"] === "true")
+            });
+          }
+        }
+      }
+      if (keyIndexNode?.tag === "key-index-list") {
+        keyIndex = {
+          timestamp: +keyIndexNode.attrs["ts"],
+          signedKeyIndex: keyIndexNode?.content,
+          expectedTimestamp: keyIndexNode.attrs["expected_ts"] ? +keyIndexNode.attrs["expected_ts"] : undefined
+        };
+      }
+    }
+    return {
+      deviceList,
+      keyIndex
+    };
+  }
+}
+//=======================================================//

package/lib/WAUSync/Protocols/USyncDisappearingModeProtocol.js

@@ -0,0 +1,29 @@
+//=======================================================//
+import { assertNodeErrorFree } from "../../WABinary/index.js";
+//=======================================================//
+export class USyncDisappearingModeProtocol {
+  constructor() {
+    this.name = "disappearing_mode";
+  }
+  getQueryElement() {
+    return {
+      tag: "disappearing_mode",
+      attrs: {}
+    };
+  }
+  getUserElement() {
+    return null;
+  }
+  parser(node) {
+    if (node.tag === "disappearing_mode") {
+      assertNodeErrorFree(node);
+      const duration = +node?.attrs.duration;
+      const setAt = new Date(+(node?.attrs.t || 0) * 1000);
+      return {
+        duration,
+        setAt
+      };
+    }
+  }
+}
+//=======================================================//

package/lib/WAUSync/Protocols/USyncStatusProtocol.js

@@ -0,0 +1,39 @@
+//=======================================================//
+import { assertNodeErrorFree } from "../../WABinary/index.js";
+export class USyncStatusProtocol {
+  constructor() {
+    this.name = "status";
+  }
+  getQueryElement() {
+    return {
+      tag: "status",
+      attrs: {}
+    };
+  }
+  getUserElement() {
+    return null;
+  }
+  parser(node) {
+    if (node.tag === "status") {
+      assertNodeErrorFree(node);
+      let status = node?.content?.toString() ?? null;
+      const setAt = new Date(+(node?.attrs.t || 0) * 1000);
+      if (!status) {
+        if (node.attrs?.code && +node.attrs.code === 401) {
+          status = "";
+        }
+        else {
+          status = null;
+        }
+      }
+      else if (typeof status === "string" && status.length === 0) {
+        status = null;
+      }
+      return {
+        status,
+        setAt
+      };
+    }
+  }
+}
+//=======================================================//

package/lib/WAUSync/Protocols/UsyncBotProfileProtocol.js

@@ -0,0 +1,53 @@
+//=======================================================//
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from "../../WABinary/index.js";
+import { USyncUser } from "../USyncUser.js";
+//=======================================================//
+export class USyncBotProfileProtocol {
+  constructor() {
+    this.name = "bot";
+  }
+  getQueryElement() {
+    return {
+      tag: "bot",
+      attrs: {},
+      content: [{ tag: "profile", attrs: { v: "1" } }]
+    };
+  }
+  getUserElement(user) {
+    return {
+      tag: "bot",
+      attrs: {},
+      content: [{ tag: "profile", attrs: { persona_id: user.personaId } }]
+    };
+  }
+  parser(node) {
+    const botNode = getBinaryNodeChild(node, "bot");
+    const profile = getBinaryNodeChild(botNode, "profile");
+    const commandsNode = getBinaryNodeChild(profile, "commands");
+    const promptsNode = getBinaryNodeChild(profile, "prompts");
+    const commands = [];
+    const prompts = [];
+    for (const command of getBinaryNodeChildren(commandsNode, "command")) {
+      commands.push({
+        name: getBinaryNodeChildString(command, "name"),
+        description: getBinaryNodeChildString(command, "description")
+      });
+    }
+    for (const prompt of getBinaryNodeChildren(promptsNode, "prompt")) {
+      prompts.push(`${getBinaryNodeChildString(prompt, "emoji")} ${getBinaryNodeChildString(prompt, "text")}`);
+    }
+    return {
+      isDefault: !!getBinaryNodeChild(profile, "default"),
+      jid: node.attrs.jid,
+      name: getBinaryNodeChildString(profile, "name"),
+      attributes: getBinaryNodeChildString(profile, "attributes"),
+      description: getBinaryNodeChildString(profile, "description"),
+      category: getBinaryNodeChildString(profile, "category"),
+      personaId: profile.attrs["persona_id"],
+      commandsDescription: getBinaryNodeChildString(commandsNode, "description"),
+      commands,
+      prompts
+    };
+  }
+}
+//=======================================================//

package/lib/WAUSync/Protocols/UsyncLIDProtocol.js

@@ -0,0 +1,30 @@
+//=======================================================//
+export class USyncLIDProtocol {
+  constructor() {
+    this.name = "lid";
+  }
+  getQueryElement() {
+    return {
+      tag: "lid",
+      attrs: {}
+    };
+  }
+  getUserElement(user) {
+    if (user.lid) {
+      return {
+        tag: "lid",
+        attrs: { jid: user.lid }
+      };
+    }
+    else {
+      return null;
+    }
+  }
+  parser(node) {
+    if (node.tag === "lid") {
+      return node.attrs.val;
+    }
+    return null;
+  }
+}
+//=======================================================//

package/lib/WAUSync/Protocols/index.js

@@ -0,0 +1,6 @@
+//=======================================================//
+export * from "./USyncDisappearingModeProtocol.js";
+export * from "./USyncContactProtocol.js";
+export * from "./USyncDeviceProtocol.js";
+export * from "./USyncStatusProtocol.js";
+//=======================================================//

package/lib/WAUSync/USyncQuery.js

@@ -0,0 +1,90 @@
+//=======================================================//
+import { USyncContactProtocol, USyncDeviceProtocol, USyncDisappearingModeProtocol, USyncStatusProtocol } from "./Protocols/index.js";
+import { USyncBotProfileProtocol } from "./Protocols/UsyncBotProfileProtocol.js";
+import { USyncLIDProtocol } from "./Protocols/UsyncLIDProtocol.js";
+import { getBinaryNodeChild } from "../WABinary/index.js";
+import { USyncUser } from "./USyncUser.js";
+//=======================================================//
+export class USyncQuery {
+  constructor() {
+    this.protocols = [];
+    this.users = [];
+    this.context = "interactive";
+    this.mode = "query";
+  }
+  withMode(mode) {
+    this.mode = mode;
+    return this;
+  }
+  withContext(context) {
+    this.context = context;
+    return this;
+  }
+  withUser(user) {
+    this.users.push(user);
+    return this;
+  }
+  parseUSyncQueryResult(result) {
+    if (!result || result.attrs.type !== "result") {
+      return;
+    }
+    const protocolMap = Object.fromEntries(this.protocols.map(protocol => {
+      return [protocol.name, protocol.parser];
+    }));
+    const queryResult = {
+      list: [],
+      sideList: []
+    };
+    const usyncNode = getBinaryNodeChild(result, "usync");
+    const listNode = usyncNode ? getBinaryNodeChild(usyncNode, "list") : undefined;
+    if (listNode?.content && Array.isArray(listNode.content)) {
+      queryResult.list = listNode.content.reduce((acc, node) => {
+        const id = node?.attrs.jid;
+        if (id) {
+          const data = Array.isArray(node?.content)
+            ? Object.fromEntries(node.content
+              .map(content => {
+              const protocol = content.tag;
+              const parser = protocolMap[protocol];
+              if (parser) {
+                return [protocol, parser(content)];
+              }
+              else {
+                return [protocol, null];
+              }
+            })
+              .filter(([, b]) => b !== null))
+            : {};
+          acc.push({ ...data, id });
+        }
+        return acc;
+      }, []);
+    }
+    return queryResult;
+  }
+  withDeviceProtocol() {
+    this.protocols.push(new USyncDeviceProtocol());
+    return this;
+  }
+  withContactProtocol() {
+    this.protocols.push(new USyncContactProtocol());
+    return this;
+  }
+  withStatusProtocol() {
+    this.protocols.push(new USyncStatusProtocol());
+    return this;
+  }
+  withDisappearingModeProtocol() {
+    this.protocols.push(new USyncDisappearingModeProtocol());
+    return this;
+  }
+  withBotProfileProtocol() {
+    this.protocols.push(new USyncBotProfileProtocol());
+    return this;
+  }
+  withLIDProtocol() {
+    this.protocols.push(new USyncLIDProtocol());
+    return this;
+  }
+}
+//=======================================================//

package/lib/WAUSync/USyncUser.js

@@ -0,0 +1,24 @@
+//=======================================================//
+export class USyncUser {
+  withId(id) {
+    this.id = id;
+    return this;
+  }
+  withLid(lid) {
+    this.lid = lid;
+    return this;
+  }
+  withPhone(phone) {
+    this.phone = phone;
+    return this;
+  }
+  withType(type) {
+    this.type = type;
+    return this;
+  }
+  withPersonaId(personaId) {
+    this.personaId = personaId;
+    return this;
+  }
+}
+//=======================================================//

package/lib/WAUSync/index.js

@@ -0,0 +1,5 @@
+//=======================================================//
+export * from "./Protocols/index.js";
+export * from "./USyncQuery.js";
+export * from "./USyncUser.js";
+//=======================================================//

package/lib/index.js

@@ -0,0 +1,15 @@
+//=======================================================//
+import makeWASocket from "./Socket/index.js";
+//=======================================================//
+export * from "./Defaults/index.js";
+export * from "./WABinary/index.js";
+export * from "../WAProto/index.js";
+export * from "./WAUSync/index.js";
+export * from "./Store/index.js";
+export * from "./Utils/index.js";
+export * from "./Types/index.js";
+export * from "./WAM/index.js";
+//=======================================================//
+export { makeWASocket };
+export default makeWASocket;
+//=======================================================//

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@skyzopedia/baileys-mod",
+  "version": "3.0.2",
+  "description": "Websocket Whatsapp API for Node.js",
+  "keywords": [
+    "whatsapp",
+    "websocket",
+    "api",
+    "nodejs",
+    "baileys",
+    "wabot",
+    "proto",
+    "whatsapp-websocket"
+  ],
+  "homepage": "https://github.com/skyzopedia/Baileys",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/skyzopedia/Baileys.git"
+  },
+  "license": "MIT",
+  "author": "Skyzopedia",
+  "main": "./lib/index.js",
+  "files": [
+    "lib/*",
+    "WAProto/*"
+  ],
+  "scripts": {
+    "changelog:update": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "changelog:preview": "conventional-changelog -p angular -u",
+    "changelog:last": "conventional-changelog -p angular -r 2",
+    "gen:protobuf": "sh WAProto/GenerateStatics.sh",
+    "example": "node --inspect Example/example.js",
+    "lint": "eslint src --ext .js",
+    "lint:fix": "yarn lint --fix",
+    "release": "release-it",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@whiskeysockets/eslint-config": "github:whiskeysockets/eslint-config",
+    "@cacheable/node-cache": "*",
+    "gradient-string": "2.0.2",
+    "libsignal-xeuka": "*",
+    "moment-timezone": "*",
+    "music-metadata": "*",
+    "cache-manager": "*",
+    "async-mutex": "*",
+    "@hapi/boom": "*",
+    "pbjs": "^0.0.14",
+    "protobufjs": "*",
+    "lru-cache": "*",
+    "readline": "*",
+    "p-queue": "*",
+    "lodash": "*",
+    "figlet": "*",
+    "axios": "*",
+    "path": "*",
+    "pino": "*",
+    "ws": "*",
+    "fs": "*",
+    "os": "*"
+  },
+  "devDependencies": {
+    "conventional-changelog-cli": "*",
+    "link-preview-js": "*",
+    "protobufjs-cli": "*",
+    "cache-manager": "*",
+    "@types/jest": "*",
+    "@types/node": "*",
+    "release-it": "*",
+    "@types/ws": "*",
+    "eslint": "*",
+    "jest": "*",
+    "json": "*",
+    "open": "*"
+  },
+  "peerDependencies": {
+    "link-preview-js": "*",
+    "audio-decode": "*",
+    "jimp": ">=0.16.0"
+  },
+  "peerDependenciesMeta": {
+    "audio-decode": {
+      "optional": true
+    },
+    "jimp": {
+      "optional": true
+    },
+    "link-preview-js": {
+      "optional": true
+    }
+  },
+  "packageManager": "yarn@1.22.19",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "bugs": {
+    "url": "https://github.com/skyzopedia/Baileys/issues"
+  }
+}