@skyzopedia/baileys-mod 5.0.8 → 6.0.0

package/lib/Signal/libsignal.js

@@ -1,324 +1,174 @@
-//=======================================================//
-import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from "../WABinary/index.js";
-import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from "./Group/index.js";
-import { SenderKeyRecord } from "./Group/sender-key-record.js";
-import { SenderKeyName } from "./Group/sender-key-name.js";
-import { generateSignalPubKey } from "../Utils/index.js";
-import { LIDMappingStore } from "./lid-mapping.js";
-import * as libsignal from "libsignal-xeuka";
-import { LRUCache } from "lru-cache";
-//=======================================================//
-export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
-  const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc);
-  const storage = signalStorage(auth, lidMapping);
-  const parsedKeys = auth.keys;
-  const migratedSessionCache = new LRUCache({
-    ttl: 7 * 24 * 60 * 60 * 1000,
-    ttlAutopurge: true,
-    updateAgeOnGet: true
-  });
-  const repository = {
-    decryptGroupMessage({ group, authorJid, msg }) {
-      const senderName = jidToSignalSenderKeyName(group, authorJid);
-      const cipher = new GroupCipher(storage, senderName);
-      return parsedKeys.transaction(async () => {
-        return cipher.decrypt(msg);
-      }, group);
-    },
-    async processSenderKeyDistributionMessage({ item, authorJid }) {
-      const builder = new GroupSessionBuilder(storage);
-      if (!item.groupId) {
-        throw new Error("Group ID is required for sender key distribution message");
-      }
-      const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
-      const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
-      const senderNameStr = senderName.toString();
-      const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [senderNameStr]);
-      if (!senderKey) {
-        await storage.storeSenderKey(senderName, new SenderKeyRecord());
-      }
-      return parsedKeys.transaction(async () => {
-        const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [senderNameStr]);
-        if (!senderKey) {
-          await storage.storeSenderKey(senderName, new SenderKeyRecord());
-        }
-        await builder.process(senderName, senderMsg);
-      }, item.groupId);
-    },
-    async decryptMessage({ jid, type, ciphertext }) {
-      const addr = jidToSignalProtocolAddress(jid);
-      const session = new libsignal.SessionCipher(storage, addr);
-      async function doDecrypt() {
-        let result;
-        switch (type) {
-          case "pkmsg":
-            result = await session.decryptPreKeyWhisperMessage(ciphertext);
-            break;
-          case "msg":
-            result = await session.decryptWhisperMessage(ciphertext);
-            break;
-        }
-        return result;
-      }
-      return parsedKeys.transaction(async () => {
-        return await doDecrypt();
-      }, jid);
-    },
-    async encryptMessage({ jid, data }) {
-      const addr = jidToSignalProtocolAddress(jid);
-      const cipher = new libsignal.SessionCipher(storage, addr);
-      return parsedKeys.transaction(async () => {
-        const { type: sigType, body } = await cipher.encrypt(data);
-        const type = sigType === 3 ? "pkmsg" : "msg";
-        return { type, ciphertext: Buffer.from(body, "binary") };
-      }, jid);
-    },
-    async encryptGroupMessage({ group, meId, data }) {
-      const senderName = jidToSignalSenderKeyName(group, meId);
-      const builder = new GroupSessionBuilder(storage);
-      const senderNameStr = senderName.toString();
-      return parsedKeys.transaction(async () => {
-        const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [senderNameStr]);
-        if (!senderKey) {
-          await storage.storeSenderKey(senderName, new SenderKeyRecord());
-        }
-        const senderKeyDistributionMessage = await builder.create(senderName);
-        const session = new GroupCipher(storage, senderName);
-        const ciphertext = await session.encrypt(data);
-        return {
-          ciphertext,
-          senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
         };
-      }, group);
-    },
-    async injectE2ESession({ jid, session }) {
-      logger.trace({ jid }, "injecting E2EE session");
-      const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-      return parsedKeys.transaction(async () => {
-        await cipher.initOutgoing(session);
-      }, jid);
-    },
-    jidToSignalProtocolAddress(jid) {
-      return jidToSignalProtocolAddress(jid).toString();
-    },
-    lidMapping,
-    async validateSession(jid) {
-      try {
-        const addr = jidToSignalProtocolAddress(jid);
-        const session = await storage.loadSession(addr.toString());
-        if (!session) {
-          return { exists: false, reason: "no session" };
-        }
-        if (!session.haveOpenSession()) {
-          return { exists: false, reason: "no open session" };
-        }
-        return { exists: true };
-      }
-      catch (error) {
-        return { exists: false, reason: "validation error" };
-      }
-    },
-    async deleteSession(jids) {
-      if (!jids.length)
-        return;
-      const sessionUpdates = {};
-      jids.forEach(jid => {
-        const addr = jidToSignalProtocolAddress(jid);
-        sessionUpdates[addr.toString()] = null;
-      });
-      return parsedKeys.transaction(async () => {
-        await auth.keys.set({ session: sessionUpdates });
-      }, `delete-${jids.length}-sessions`);
-    },
-    async migrateSession(fromJid, toJid) {
-      if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid)))
-        return { migrated: 0, skipped: 0, total: 0 };
-      if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) {
-        return { migrated: 0, skipped: 0, total: 1 };
-      }
-      const { user } = jidDecode(fromJid);
-      logger.debug({ fromJid }, "bulk device migration - loading all user devices");
-      const { [user]: userDevices } = await parsedKeys.get("device-list", [user]);
-      if (!userDevices) {
-        return { migrated: 0, skipped: 0, total: 0 };
-      }
-      const { device: fromDevice } = jidDecode(fromJid);
-      const fromDeviceStr = fromDevice?.toString() || "0";
-      if (!userDevices.includes(fromDeviceStr)) {
-        userDevices.push(fromDeviceStr);
-      }
-      const uncachedDevices = userDevices.filter(device => {
-        const deviceKey = `${user}.${device}`;
-        return !migratedSessionCache.has(deviceKey);
-      });
-      const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`);
-      const existingSessions = await parsedKeys.get("session", deviceSessionKeys);
-      const deviceJids = [];
-      for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
-        if (sessionData) {
-          const deviceStr = sessionKey.split(".")[1];
-          if (!deviceStr)
-            continue;
-          const deviceNum = parseInt(deviceStr);
-          let jid = deviceNum === 0 ? `${user}@s.whatsapp.net` : `${user}:${deviceNum}@s.whatsapp.net`;
-          if (deviceNum === 99) {
-            jid = `${user}:99@hosted`;
-          }
-          deviceJids.push(jid);
-        }
-      }
-      logger.debug({
-        fromJid,
-        totalDevices: userDevices.length,
-        devicesWithSessions: deviceJids.length,
-        devices: deviceJids
-      }, "bulk device migration complete - all user devices processed");
-      return parsedKeys.transaction(async () => {
-        const migrationOps = deviceJids.map(jid => {
-          const lidWithDevice = transferDevice(jid, toJid);
-          const fromDecoded = jidDecode(jid);
-          const toDecoded = jidDecode(lidWithDevice);
-          return {
-            fromJid: jid,
-            toJid: lidWithDevice,
-            pnUser: fromDecoded.user,
-            lidUser: toDecoded.user,
-            deviceId: fromDecoded.device || 0,
-            fromAddr: jidToSignalProtocolAddress(jid),
-            toAddr: jidToSignalProtocolAddress(lidWithDevice)
-          };
-        });
-        const totalOps = migrationOps.length;
-        let migratedCount = 0;
-        const pnAddrStrings = Array.from(new Set(migrationOps.map(op => op.fromAddr.toString())));
-        const pnSessions = await parsedKeys.get("session", pnAddrStrings);
-        const sessionUpdates = {};
-        for (const op of migrationOps) {
-          const pnAddrStr = op.fromAddr.toString();
-          const lidAddrStr = op.toAddr.toString();
-          const pnSession = pnSessions[pnAddrStr];
-          if (pnSession) {
-            const fromSession = libsignal.SessionRecord.deserialize(pnSession);
-            if (fromSession.haveOpenSession()) {
-              sessionUpdates[lidAddrStr] = fromSession.serialize();
-              sessionUpdates[pnAddrStr] = null;
-              migratedCount++;
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLibSignalRepository = makeLibSignalRepository;
+const libsignal = __importStar(require("libsignal"));
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const sender_key_name_1 = require("./Group/sender-key-name");
+const sender_key_record_1 = require("./Group/sender-key-record");
+const Group_1 = require("./Group");
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth);
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new Group_1.GroupCipher(storage, senderName);
+            return cipher.decrypt(msg);
+        },
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
             }
-          }
-        }
-        if (Object.keys(sessionUpdates).length > 0) {
-          await parsedKeys.set({ session: sessionUpdates });
-          logger.debug({ migratedSessions: migratedCount }, "bulk session migration complete");
-          for (const op of migrationOps) {
-            if (sessionUpdates[op.toAddr.toString()]) {
-              const deviceKey = `${op.pnUser}.${op.deviceId}`;
-              migratedSessionCache.set(deviceKey, true);
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
-          }
+            await builder.process(senderName, senderMsg);
+        },
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new libsignal.SessionCipher(storage, addr);
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+                default:
+                    throw new Error(`Unknown message type: ${type}`);
+            }
+            return result;
+        },
+        async encryptMessage({ jid, data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new libsignal.SessionCipher(storage, addr);
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
+        },
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+            };
+        },
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            await cipher.initOutgoing(session);
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
         }
-        const skippedCount = totalOps - migratedCount;
-        return { migrated: migratedCount, skipped: skippedCount, total: totalOps };
-      }, `migrate-${deviceJids.length}-sessions-${jidDecode(toJid)?.user}`);
-    }
-  };
-  return repository;
+    };
 }
-//=======================================================//
 const jidToSignalProtocolAddress = (jid) => {
-  const decoded = jidDecode(jid);
-  const { user, device, server, domainType } = decoded;
-  if (!user) {
-    throw new Error(`JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`);
-  }
-  const signalUser = domainType !== WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user;
-  const finalDevice = device || 0;
-  if (device === 99 && decoded.server !== "hosted" && decoded.server !== "hosted.lid") {
-    throw new Error("Unexpected non-hosted device JID with device 99. This ID seems invalid. ID:" + jid);
-  }
-  return new libsignal.ProtocolAddress(signalUser, finalDevice);
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
 };
-//=======================================================//
 const jidToSignalSenderKeyName = (group, user) => {
-  return new SenderKeyName(group, jidToSignalProtocolAddress(user));
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-//=======================================================//
-function signalStorage({ creds, keys }, lidMapping) {
-  const resolveLIDSignalAddress = async (id) => {
-    if (id.includes(".")) {
-      const [deviceId, device] = id.split(".");
-      const [user, domainType_] = deviceId.split("_");
-      const domainType = parseInt(domainType_ || "0");
-      if (domainType === WAJIDDomains.LID || domainType === WAJIDDomains.HOSTED_LID)
-        return id;
-      const pnJid = `${user}${device !== "0" ? `:${device}` : ""}@${domainType === WAJIDDomains.HOSTED ? "hosted" : "s.whatsapp.net"}`;
-      const lidForPN = await lidMapping.getLIDForPN(pnJid);
-      if (lidForPN) {
-        const lidAddr = jidToSignalProtocolAddress(lidForPN);
-        return lidAddr.toString();
-      }
-    }
-    return id;
-  };
-  return {
-    loadSession: async (id) => {
-      try {
-        const wireJid = await resolveLIDSignalAddress(id);
-        const { [wireJid]: sess } = await keys.get("session", [wireJid]);
-        if (sess) {
-          return libsignal.SessionRecord.deserialize(sess);
+function signalStorage({ creds, keys }) {
+    return {
+        loadSession: async (id) => {
+            const { [id]: sess } = await keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
+            }
+        },
+        storeSession: async (id, session) => {
+            await keys.set({ session: { [id]: session.serialize() } });
+        },
+        isTrustedIdentity: () => {
+            return true;
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString();
+            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                };
+            }
+        },
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey;
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            };
+        },
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString();
+            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            if (key) {
+                return sender_key_record_1.SenderKeyRecord.deserialize(key);
+            }
+            return new sender_key_record_1.SenderKeyRecord();
+        },
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString();
+            const serialized = JSON.stringify(key.serialize());
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
+        },
+        getOurRegistrationId: () => creds.registrationId,
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+            };
         }
-      }
-      catch (e) {
-        return null;
-      }
-      return null;
-    },
-    storeSession: async (id, session) => {
-      const wireJid = await resolveLIDSignalAddress(id);
-      await keys.set({ session: { [wireJid]: session.serialize() } });
-    },
-    isTrustedIdentity: () => {
-      return true;
-    },
-    loadPreKey: async (id) => {
-      const keyId = id.toString();
-      const { [keyId]: key } = await keys.get("pre-key", [keyId]);
-      if (key) {
-        return {
-          privKey: Buffer.from(key.private),
-          pubKey: Buffer.from(key.public)
-        };
-      }
-    },
-    removePreKey: (id) => keys.set({ "pre-key": { [id]: null } }),
-    loadSignedPreKey: () => {
-      const key = creds.signedPreKey;
-      return {
-        privKey: Buffer.from(key.keyPair.private),
-        pubKey: Buffer.from(key.keyPair.public)
-      };
-    },
-    loadSenderKey: async (senderKeyName) => {
-      const keyId = senderKeyName.toString();
-      const { [keyId]: key } = await keys.get("sender-key", [keyId]);
-      if (key) {
-        return SenderKeyRecord.deserialize(key);
-      }
-      return new SenderKeyRecord();
-    },
-    storeSenderKey: async (senderKeyName, key) => {
-      const keyId = senderKeyName.toString();
-      const serialized = JSON.stringify(key.serialize());
-      await keys.set({ "sender-key": { [keyId]: Buffer.from(serialized, "utf-8") } });
-    },
-    getOurRegistrationId: () => creds.registrationId,
-    getOurIdentity: () => {
-      const { signedIdentityKey } = creds;
-      return {
-        privKey: Buffer.from(signedIdentityKey.private),
-        pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public))
-      };
-    }
-  };
+    };
 }
-//=======================================================//

package/lib/Socket/Client/abstract-socket-client.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+import { SocketConfig } from '../../Types';
+export declare abstract class AbstractSocketClient extends EventEmitter {
+    url: URL;
+    config: SocketConfig;
+    abstract get isOpen(): boolean;
+    abstract get isClosed(): boolean;
+    abstract get isClosing(): boolean;
+    abstract get isConnecting(): boolean;
+    constructor(url: URL, config: SocketConfig);
+    abstract connect(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/abstract-socket-client.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './abstract-socket-client';
+export * from './mobile-socket-client';
+export * from './web-socket-client';

package/lib/Socket/Client/index.js

@@ -1,4 +1,19 @@
-//=======================================================//
-export * from "./websocket.js";
-export * from "./types.js";
-//=======================================================//
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-socket-client"), exports);
+__exportStar(require("./mobile-socket-client"), exports);
+__exportStar(require("./web-socket-client"), exports);

package/lib/Socket/Client/mobile-socket-client.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Socket } from 'net';
+import { AbstractSocketClient } from './abstract-socket-client';
+export declare class MobileSocketClient extends AbstractSocketClient {
+    protected socket: Socket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/mobile-socket-client.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileSocketClient = void 0;
+const net_1 = require("net");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open';
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening';
+    }
+    async connect() {
+        var _a;
+        if (this.socket) {
+            return;
+        }
+        if (this.config.agent) {
+            throw new Error('There are not support for proxy agent for mobile connection');
+        }
+        else {
+            this.socket = (0, net_1.connect)({
+                host: this.url.hostname,
+                port: Number(this.url.port) || 443
+            });
+        }
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'ready', 'timeout'];
+        for (const event of events) {
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, (...args) => this.emit(event, ...args));
+        }
+        this.socket.on('data', (...args) => this.emit('message', ...args));
+        this.socket.on('ready', (...args) => this.emit('open', ...args));
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.socket.end(resolve);
+            this.socket = null;
+        });
+    }
+    send(str, cb) {
+        if (this.socket === null) {
+            return false;
+        }
+        return this.socket.write(str, undefined, cb);
+    }
+}
+exports.MobileSocketClient = MobileSocketClient;

package/lib/Socket/Client/web-socket-client.d.ts

@@ -0,0 +1,12 @@
+import WebSocket from 'ws';
+import { AbstractSocketClient } from './abstract-socket-client';
+export declare class WebSocketClient extends AbstractSocketClient {
+    protected socket: WebSocket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}