@aseppxyzz12/baileys 1.1.8

package/lib/Signal/libsignal.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    SessionCipher: SessionCipher,
+    SessionBuilder: SessionBuilder,
+    SessionRecord: SessionRecord,
+    ProtocolAddress: ProtocolAddress,
+} = require("libsignal");
+const { generateSignalPubKey: generateSignalPubKey } = require("../Utils");
+const {
+    isHostedLidUser: isHostedLidUser,
+    isHostedPnUser: isHostedPnUser,
+    isLidUser: isLidUser,
+    isPnUser: isPnUser,
+    jidDecode: jidDecode,
+    transferDevice: transferDevice,
+    WAJIDDomains: WAJIDDomains,
+} = require("../WABinary");
+const { SenderKeyName: SenderKeyName } = require("./Group/sender-key-name");
+const { SenderKeyRecord: SenderKeyRecord } = require("./Group/sender-key-record");
+const {
+    GroupCipher: GroupCipher,
+    GroupSessionBuilder: GroupSessionBuilder,
+    SenderKeyDistributionMessage: SenderKeyDistributionMessage,
+} = require("./Group");
+const { LRUCache: LRUCache } = require("lru-cache");
+const { LIDMappingStore: LIDMappingStore } = require("./lid-mapping");
+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: 3 * 24 * 60 * 60 * 1e3,
+        ttlAutopurge: true,
+        updateAgeOnGet: true,
+    });
+    const repository = {
+        decryptGroupMessage({ group: group, authorJid: authorJid, msg: msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new GroupCipher(storage, senderName);
+            return parsedKeys.transaction(async () => cipher.decrypt(msg), group);
+        },
+        async processSenderKeyDistributionMessage({ item: item, authorJid: 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: jid, type: type, ciphertext: ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new 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 () => await doDecrypt(), jid);
+        },
+        async encryptMessage({ jid: jid, data: data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new SessionCipher(storage, addr);
+            return parsedKeys.transaction(async () => {
+                const { type: sigType, body: body } = await cipher.encrypt(data);
+                const type = sigType === 3 ? "pkmsg" : "msg";
+                return { type: type, ciphertext: Buffer.from(body, "binary") };
+            }, jid);
+        },
+        async encryptGroupMessage({ group: group, meId: meId, data: 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: ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+                };
+            }, group);
+        },
+        async injectE2ESession({ jid: jid, session: session }) {
+            logger.trace({ jid: jid }, "injecting E2EE session");
+            const cipher = new SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            return parsedKeys.transaction(async () => {
+                await cipher.initOutgoing(session);
+            }, jid);
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
+        },
+        lidMapping: 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: user } = jidDecode(fromJid);
+            logger.debug({ fromJid: 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: 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 = SessionRecord.deserialize(pnSession);
+                            if (fromSession.haveOpenSession()) {
+                                sessionUpdates[lidAddrStr] = fromSession.serialize();
+                                sessionUpdates[pnAddrStr] = null;
+                                migratedCount++;
+                            }
+                        }
+                    }
+                    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 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: user, device: device, server: server, domainType: 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 ProtocolAddress(signalUser, finalDevice);
+};
+const jidToSignalSenderKeyName = (group, user) =>
+    new SenderKeyName(group, jidToSignalProtocolAddress(user));
+function signalStorage({ creds: creds, keys: 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 SessionRecord.deserialize(sess);
+                }
+            } catch (e) {
+                return null;
+            }
+            return null;
+        },
+        storeSession: async (id, session) => {
+            const wireJid = await resolveLIDSignalAddress(id);
+            await keys.set({ session: { [wireJid]: session.serialize() } });
+        },
+        isTrustedIdentity: () => 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: signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public)),
+            };
+        },
+    };
+}
+module.exports = { makeLibSignalRepository: makeLibSignalRepository };

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { LRUCache: LRUCache } = require("lru-cache");
+const {
+    isHostedPnUser: isHostedPnUser,
+    isLidUser: isLidUser,
+    isPnUser: isPnUser,
+    jidDecode: jidDecode,
+    jidNormalizedUser: jidNormalizedUser,
+    WAJIDDomains: WAJIDDomains,
+} = require("../WABinary");
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1e3,
+            ttlAutopurge: true,
+            updateAgeOnGet: true,
+        });
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
+    }
+    async storeLIDPNMappings(pairs) {
+        const pairMap = {};
+        for (const { lid: lid, pn: pn } of pairs) {
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = jidDecode(lid);
+            const pnDecoded = jidDecode(pn);
+            if (!lidDecoded || !pnDecoded) return;
+            const pnUser = pnDecoded.user;
+            const lidUser = lidDecoded.user;
+            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!existingLidUser) {
+                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+            if (existingLidUser === lidUser) {
+                this.logger.debug(
+                    { pnUser: pnUser, lidUser: lidUser },
+                    "LID mapping already exists, skipping"
+                );
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        this.logger.trace(
+            { pairMap: pairMap },
+            `Storing ${Object.keys(pairMap).length} pn mappings`
+        );
+        await this.keys.transaction(async () => {
+            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+                await this.keys.set({
+                    "lid-mapping": { [pnUser]: lidUser, [`${lidUser}_reverse`]: pnUser },
+                });
+                this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            }
+        }, "lid-mapping");
+    }
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
+    }
+    async getLIDsForPNs(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        for (const pn of pns) {
+            if (!isPnUser(pn) && !isHostedPnUser(pn)) continue;
+            const decoded = jidDecode(pn);
+            if (!decoded) continue;
+            const pnUser = decoded.user;
+            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!lidUser) {
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                lidUser = stored[pnUser];
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                } else {
+                    this.logger.trace(
+                        `No LID mapping found for PN user ${pnUser}; batch getting from USync`
+                    );
+                    const device = decoded.device || 0;
+                    let normalizedPn = jidNormalizedUser(pn);
+                    if (isHostedPnUser(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`;
+                    }
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device];
+                    } else {
+                        usyncFetch[normalizedPn]?.push(device);
+                    }
+                    continue;
+                }
+            }
+            lidUser = lidUser.toString();
+            if (!lidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                return null;
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === "hosted" ? "hosted.lid" : "lid"}`;
+            this.logger.trace(
+                `getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`
+            );
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn: pn };
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            if (result && result.length > 0) {
+                await this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = jidDecode(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser) continue;
+                    const lidUser = jidDecode(pair.lid)?.user;
+                    if (!lidUser) continue;
+                    for (const device of usyncFetch[pair.pn]) {
+                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted.lid" : "lid"}`;
+                        this.logger.trace(
+                            `getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`
+                        );
+                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted" : "s.whatsapp.net"}`;
+                        successfulPairs[deviceSpecificPn] = {
+                            lid: deviceSpecificLid,
+                            pn: deviceSpecificPn,
+                        };
+                    }
+                }
+            } else {
+                return null;
+            }
+        }
+        return Object.values(successfulPairs);
+    }
+    async getPNForLID(lid) {
+        if (!isLidUser(lid)) return null;
+        const decoded = jidDecode(lid);
+        if (!decoded) return null;
+        const lidUser = decoded.user;
+        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        if (!pnUser || typeof pnUser !== "string") {
+            const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+            pnUser = stored[`${lidUser}_reverse`];
+            if (!pnUser || typeof pnUser !== "string") {
+                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                return null;
+            }
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+        const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+        const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
+        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+module.exports = { LIDMappingStore: LIDMappingStore };

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.js

@@ -0,0 +1,31 @@
+"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("./types"), exports);
+__exportStar(require("./websocket"), exports);

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/types.js

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