@softtynet/zca-js 2.2.9 → 2.2.10

package/dist/cjs/realtime/handlers/reaction.handler.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+require('../../models/AutoReply.cjs');
+require('../../models/Bank.cjs');
+require('../../models/Board.cjs');
+require('../../models/Enum.cjs');
+require('../../models/FriendEvent.cjs');
+require('../../models/Group.cjs');
+require('../../models/GroupEvent.cjs');
+var Reaction = require('../../models/Reaction.cjs');
+require('../../models/Reminder.cjs');
+require('../../models/ZBusiness.cjs');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+require('crypto-js');
+require('node:crypto');
+require('node:fs');
+require('node:path');
+require('spark-md5');
+require('tough-cookie');
+require('../../context.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+async function handleRealtimeReactionPacket(listener, ctx, selfListen, cmd, parsed, cipherKey) {
+    if (cmd == 612) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { reacts, reactGroups } = parsedData;
+        for (const react of reacts) {
+            react.content = JSON.parse(react.content);
+            const reactionObject = new Reaction.Reaction(ctx.uid, react, false);
+            if (reactionObject.isSelf && !selfListen)
+                continue;
+            listener.emit("reaction", reactionObject);
+        }
+        for (const reactGroup of reactGroups) {
+            reactGroup.content = JSON.parse(reactGroup.content);
+            const reactionObject = new Reaction.Reaction(ctx.uid, reactGroup, true);
+            if (reactionObject.isSelf && !selfListen)
+                continue;
+            listener.emit("reaction", reactionObject);
+        }
+        return true;
+    }
+    if (cmd == 610 || cmd == 611) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const isGroup = cmd == 611;
+        const reacts = parsedData[isGroup ? "reactGroups" : "reacts"];
+        const reactionObjects = reacts.map((react) => new Reaction.Reaction(ctx.uid, react, isGroup));
+        listener.emit("old_reactions", reactionObjects, isGroup);
+        return true;
+    }
+    return false;
+}
+
+exports.handleRealtimeReactionPacket = handleRealtimeReactionPacket;

package/dist/cjs/realtime/handlers/status.handler.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+var ClearUnread = require('../../models/ClearUnread.cjs');
+var DeliveredMessage = require('../../models/DeliveredMessage.cjs');
+require('../../models/AutoReply.cjs');
+require('../../models/Bank.cjs');
+require('../../models/Board.cjs');
+require('../../models/Enum.cjs');
+require('../../models/FriendEvent.cjs');
+require('../../models/Group.cjs');
+require('../../models/GroupEvent.cjs');
+require('../../models/Reaction.cjs');
+require('../../models/Reminder.cjs');
+var SeenMessage = require('../../models/SeenMessage.cjs');
+var Typing = require('../../models/Typing.cjs');
+require('../../models/ZBusiness.cjs');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+require('crypto-js');
+require('node:crypto');
+require('node:fs');
+require('node:path');
+require('spark-md5');
+require('tough-cookie');
+require('../../context.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+async function handleRealtimeStatusPacket(listener, ctx, selfListen, cmd, subCmd, parsed, cipherKey) {
+    if ((cmd == 504 || cmd == 524) && subCmd == 0) {
+        const decoded = await wsCipher.decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data ?? decoded;
+        const clearUnreads = (parsedData?.clearUnreads ?? []);
+        if (Array.isArray(clearUnreads) && clearUnreads.length > 0) {
+            const items = clearUnreads.map((item) => new ClearUnread.ClearUnread(item));
+            listener.emit("unread_cleared", items);
+        }
+        return true;
+    }
+    if (cmd == 602 && subCmd == 0) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { actions } = parsedData;
+        for (const action of actions) {
+            if (action.act_type == "typing") {
+                const data = JSON.parse(`{${action.data}}`);
+                if (action.act == "typing") {
+                    const typingObject = new Typing.UserTyping(data);
+                    listener.emit("typing", typingObject);
+                }
+                else if (action.act == "gtyping") {
+                    const typingObject = new Typing.GroupTyping(data);
+                    listener.emit("typing", typingObject);
+                }
+            }
+        }
+        return true;
+    }
+    if (cmd == 502 && subCmd == 0) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { delivereds: deliveredMsgs, seens: seenMsgs } = parsedData;
+        if (Array.isArray(deliveredMsgs) && deliveredMsgs.length > 0) {
+            const deliveredObjects = deliveredMsgs.map((delivered) => new DeliveredMessage.UserDeliveredMessage(delivered));
+            listener.emit("delivered_messages", deliveredObjects);
+        }
+        if (Array.isArray(seenMsgs) && seenMsgs.length > 0) {
+            const seenObjects = seenMsgs.map((seen) => new SeenMessage.UserSeenMessage(seen));
+            listener.emit("seen_messages", seenObjects);
+        }
+        return true;
+    }
+    if (cmd == 522 && subCmd == 0) {
+        const parsedData = (await wsCipher.decodeEventData(parsed, cipherKey)).data;
+        const { delivereds: deliveredMsgs, groupSeens: groupSeenMsgs } = parsedData;
+        if (Array.isArray(deliveredMsgs) && deliveredMsgs.length > 0) {
+            let deliveredObjects = deliveredMsgs.map((delivered) => new DeliveredMessage.GroupDeliveredMessage(ctx.uid, delivered));
+            if (!selfListen)
+                deliveredObjects = deliveredObjects.filter((delivered) => !delivered.isSelf);
+            listener.emit("delivered_messages", deliveredObjects);
+        }
+        if (Array.isArray(groupSeenMsgs) && groupSeenMsgs.length > 0) {
+            let seenObjects = groupSeenMsgs.map((seen) => new SeenMessage.GroupSeenMessage(ctx.uid, seen));
+            if (!selfListen)
+                seenObjects = seenObjects.filter((seen) => !seen.isSelf);
+            listener.emit("seen_messages", seenObjects);
+        }
+        return true;
+    }
+    return false;
+}
+
+exports.handleRealtimeStatusPacket = handleRealtimeStatusPacket;

package/dist/cjs/realtime/listener.cjs

@@ -0,0 +1,381 @@
+'use strict';
+
+var EventEmitter = require('events');
+var WebSocket = require('ws');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+require('../models/SyncEvent.cjs');
+require('../models/CallEvent.cjs');
+var utils = require('../utils.cjs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var types = require('./types.cjs');
+var message_handler = require('./handlers/message.handler.cjs');
+var control_handler = require('./handlers/control.handler.cjs');
+var reaction_handler = require('./handlers/reaction.handler.cjs');
+var status_handler = require('./handlers/status.handler.cjs');
+var domains = require('../constants/domains.cjs');
+var defaults = require('../constants/defaults.cjs');
+
+class Listener extends EventEmitter {
+    ctx;
+    urls;
+    wsURL;
+    cookie;
+    userAgent;
+    ws;
+    retryCount;
+    rotateCount;
+    onConnectedCallback;
+    onClosedCallback;
+    onErrorCallback;
+    onMessageCallback;
+    cipherKey;
+    selfListen;
+    pingInterval;
+    retryTimeout;
+    watchdogTimeout;
+    consecutive1006Count = 0;
+    id = 0;
+    constructor(ctx, urls) {
+        super();
+        this.ctx = ctx;
+        this.urls = urls;
+        if (!ctx.cookie)
+            throw new ZaloApiError.ZaloApiError("Cookie is not available");
+        if (!ctx.userAgent)
+            throw new ZaloApiError.ZaloApiError("User agent is not available");
+        this.wsURL = utils.makeURL(this.ctx, this.urls[0], {
+            t: Date.now(),
+        });
+        this.retryCount = {};
+        this.rotateCount = 0;
+        for (const retry in ctx.settings.features.socket.retries) {
+            const { times, max } = ctx.settings.features.socket.retries[retry];
+            this.retryCount[retry] = {
+                count: 0,
+                max: max || 0,
+                times: typeof times === "number" ? [times] : times,
+            };
+        }
+        this.cookie = ctx.cookie.getCookieStringSync(domains.ZALO_DOMAINS.CHAT_WEB);
+        this.userAgent = ctx.userAgent;
+        this.selfListen = ctx.options.selfListen;
+        this.ws = null;
+        this.onConnectedCallback = () => { };
+        this.onClosedCallback = () => { };
+        this.onErrorCallback = () => { };
+        this.onMessageCallback = () => { };
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onConnected(cb) {
+        this.onConnectedCallback = cb;
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onClosed(cb) {
+        this.onClosedCallback = cb;
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onError(cb) {
+        this.onErrorCallback = cb;
+    }
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onMessage(cb) {
+        this.onMessageCallback = cb;
+    }
+    isRetryable(code) {
+        return (code === types.CloseReason.AbnormalClosure ||
+            this.ctx.settings.features.socket.close_and_retry_codes.includes(code));
+    }
+    canRetry(code) {
+        if (!this.isRetryable(code))
+            return false;
+        const retry = this.retryCount[code.toString()] ?? this.retryCount["internal"];
+        if (!retry || retry.count >= retry.max)
+            return false;
+        retry.count++;
+        const { count, max, times } = retry;
+        let retryTime;
+        if (count - 1 < times.length) {
+            retryTime = times[count - 1];
+        }
+        else {
+            const lastTime = times[times.length - 1] || 1000;
+            const multiplier = Math.min(Math.pow(1.5, count - times.length), 10);
+            const jitter = Math.floor(Math.random() * 1000);
+            retryTime = Math.min(Math.floor(lastTime * multiplier) + jitter, defaults.ZALO_DEFAULTS.SOCKET.MAX_RETRY_BACKOFF_MS);
+        }
+        utils.logger(this.ctx).verbose(`Retry for code ${code} in ${retryTime}ms (${count}/${max})`);
+        return retryTime;
+    }
+    resetRetryCount() {
+        for (const retry of Object.values(this.retryCount)) {
+            retry.count = 0;
+        }
+    }
+    resetWatchdog() {
+        if (this.watchdogTimeout)
+            clearTimeout(this.watchdogTimeout);
+        this.watchdogTimeout = setTimeout(() => {
+            utils.logger(this.ctx).verbose("Watchdog timeout: no packet/pong received from Zalo WebSocket in 50s. Forcing reconnect...");
+            if (this.ws) {
+                try {
+                    if (typeof this.ws.terminate === "function") {
+                        this.ws.terminate();
+                    }
+                    else if (typeof this.ws.close === "function") {
+                        this.ws.close(types.CloseReason.AbnormalClosure);
+                    }
+                }
+                catch {
+                    // Ignore if already terminated
+                }
+            }
+        }, defaults.ZALO_DEFAULTS.SOCKET.WATCHDOG_TIMEOUT_MS);
+    }
+    shouldRotate(code) {
+        if (code === types.CloseReason.AbnormalClosure) {
+            this.consecutive1006Count++;
+            if (this.consecutive1006Count >= defaults.ZALO_DEFAULTS.SOCKET.CONSECUTIVE_1006_ROTATE_THRESHOLD) {
+                this.consecutive1006Count = 0;
+                return true;
+            }
+            return false;
+        }
+        this.consecutive1006Count = 0;
+        return this.ctx.settings.features.socket.rotate_error_codes.includes(code);
+    }
+    rotateEndpoint() {
+        this.rotateCount = (this.rotateCount + 1) % this.urls.length;
+        this.wsURL = utils.makeURL(this.ctx, this.urls[this.rotateCount], {
+            t: Date.now(),
+        });
+        utils.logger(this.ctx).verbose(`Rotating endpoint to ${this.wsURL}`);
+    }
+    start({ retryOnClose = false } = {}) {
+        if (this.retryTimeout) {
+            clearTimeout(this.retryTimeout);
+            this.retryTimeout = undefined;
+        }
+        if (this.ws) {
+            const state = this.ws.readyState;
+            if (state === WebSocket.CONNECTING || state === WebSocket.OPEN) {
+                utils.logger(this.ctx).warn("Listener is already active or connecting. Skipping duplicate start().");
+                return;
+            }
+            try {
+                this.ws.removeAllListeners();
+                this.ws.close();
+            }
+            catch {
+                // ignore
+            }
+            this.ws = null;
+        }
+        this.wsURL = utils.makeURL(this.ctx, this.urls[this.rotateCount], {
+            t: Date.now(),
+        });
+        const cookie = this.ctx.cookie.getCookieStringSync(domains.ZALO_DOMAINS.CHAT_WEB);
+        const ws = new WebSocket(this.wsURL, {
+            headers: {
+                "accept-language": utils.getBrowserLanguage(this.ctx.language),
+                "cache-control": "no-cache",
+                connection: "Upgrade",
+                host: new URL(this.wsURL).host,
+                origin: domains.ZALO_DOMAINS.CHAT_WEB,
+                pragma: "no-cache",
+                "sec-websocket-extensions": "permessage-deflate; client_max_window_bits",
+                "sec-websocket-version": "13",
+                upgrade: "websocket",
+                "user-agent": this.userAgent,
+                cookie,
+            },
+            agent: this.ctx.options.agent,
+        });
+        this.ws = ws;
+        ws.onopen = () => {
+            this.consecutive1006Count = 0;
+            this.resetRetryCount();
+            this.resetWatchdog();
+            this.onConnectedCallback();
+            this.emit("connected");
+        };
+        ws.onclose = (event) => {
+            this.reset();
+            this.emit("disconnected", event.code, event.reason);
+            const retry = retryOnClose &&
+                this.isRetryable(event.code) &&
+                this.canRetry(event.code);
+            if (retry && retryOnClose) {
+                const shouldRotate = this.shouldRotate(event.code);
+                if (shouldRotate) {
+                    this.rotateEndpoint();
+                }
+                this.emit("reconnecting", event.code);
+                this.retryTimeout = setTimeout(() => {
+                    try {
+                        this.start({ retryOnClose: true });
+                    }
+                    catch (error) {
+                        utils.logger(this.ctx).error("Failed to auto-restart listener on retry timeout:", error);
+                    }
+                }, retry);
+            }
+            else {
+                this.onClosedCallback(event.code, event.reason);
+                this.emit("closed", event.code, event.reason);
+            }
+        };
+        ws.onerror = (event) => {
+            this.onErrorCallback(event);
+            this.emit("error", event);
+        };
+        ws.onmessage = async (event) => {
+            this.resetWatchdog();
+            this.emit("pong");
+            const { data } = event;
+            if (!(data instanceof Buffer))
+                return;
+            const encodedHeader = data.subarray(0, 4);
+            const [version, cmd, subCmd] = getHeader(encodedHeader);
+            try {
+                const dataToDecode = data.subarray(4);
+                const decodedData = new TextDecoder("utf-8").decode(dataToDecode);
+                if (decodedData.length == 0)
+                    return;
+                const parsed = JSON.parse(decodedData);
+                if (version == 1 && cmd == 1 && subCmd == 1 && utils.hasOwn(parsed, "key")) {
+                    this.cipherKey = parsed.key;
+                    this.emit("cipher_key", this.cipherKey);
+                    if (this.pingInterval)
+                        clearInterval(this.pingInterval);
+                    const ping = () => {
+                        const payload = {
+                            version: 1,
+                            cmd: 2,
+                            subCmd: 1,
+                            data: { eventId: Date.now() },
+                        };
+                        this.sendWs(payload, false);
+                        this.emit("ping");
+                    };
+                    const pingIntervalTime = Math.min(Math.max(this.ctx.settings?.features?.socket?.ping_interval ||
+                        defaults.ZALO_DEFAULTS.SOCKET.DEFAULT_PING_INTERVAL_MS, defaults.ZALO_DEFAULTS.SOCKET.MIN_PING_INTERVAL_MS), defaults.ZALO_DEFAULTS.SOCKET.MAX_PING_INTERVAL_MS);
+                    this.pingInterval = setInterval(() => {
+                        ping();
+                    }, pingIntervalTime);
+                }
+                await message_handler.handleRealtimeMessagePacket(this, this.ctx, this.selfListen, this.onMessageCallback, version, cmd, subCmd, parsed, this.cipherKey);
+                await control_handler.handleRealtimeControlPacket(this, this.ctx, this.selfListen, version, cmd, subCmd, parsed, this.cipherKey);
+                await reaction_handler.handleRealtimeReactionPacket(this, this.ctx, this.selfListen, cmd, parsed, this.cipherKey);
+                await status_handler.handleRealtimeStatusPacket(this, this.ctx, this.selfListen, cmd, subCmd, parsed, this.cipherKey);
+                if (version == 1 && cmd == 3000 && subCmd == 0) {
+                    utils.logger(this.ctx).error();
+                    utils.logger(this.ctx).error("Another connection is opened, closing this one");
+                    utils.logger(this.ctx).error();
+                    if (ws.readyState !== WebSocket.CLOSED)
+                        ws.close(types.CloseReason.DuplicateConnection);
+                }
+            }
+            catch (error) {
+                if (error instanceof ZaloApiError.ZaloApiError &&
+                    error.message.includes("Invalid data length or missing cipher key")) {
+                    utils.logger(this.ctx).verbose("Ignored undecryptable Zalo packet. This is normal for some reaction/system events.");
+                    return;
+                }
+                this.onErrorCallback(error);
+                this.emit("error", error);
+            }
+        };
+    }
+    stop() {
+        if (this.retryTimeout)
+            clearTimeout(this.retryTimeout);
+        if (this.watchdogTimeout)
+            clearTimeout(this.watchdogTimeout);
+        if (this.ws) {
+            if (this.ws.readyState !== WebSocket.CLOSED) {
+                this.ws.close(types.CloseReason.ManualClosure);
+            }
+        }
+        this.reset();
+    }
+    sendWs(payload, requireId = true) {
+        if (this.ws) {
+            if (requireId)
+                payload.data["req_id"] = `req_${this.id++}`;
+            const encodedData = new TextEncoder().encode(JSON.stringify(payload.data));
+            const dataLength = encodedData.length;
+            const data = new DataView(Buffer.alloc(4 + dataLength).buffer);
+            data.setUint8(0, payload.version);
+            data.setInt32(1, payload.cmd, true);
+            data.setInt8(3, payload.subCmd);
+            encodedData.forEach((e, i) => {
+                data.setUint8(4 + i, e);
+            });
+            this.ws.send(data);
+        }
+    }
+    /**
+     * Request old messages from Zalo WebSocket queue (`cmd 510` for User, `cmd 511` for Group).
+     * When `lastMsgId` is `null` or omitted, defaults to `"10000000000000000"` to fetch the latest offline messages.
+     *
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID (`actionId`) for pagination
+     */
+    requestOldMessages(threadType, lastMsgId = null) {
+        const payload = {
+            version: 1,
+            cmd: threadType === Enum.ThreadType.User ? 510 : 511,
+            subCmd: 1,
+            data: { first: true, lastId: lastMsgId ?? defaults.ZALO_DEFAULTS.SOCKET.OLD_MSG_INITIAL_CURSOR, preIds: [] },
+        };
+        this.sendWs(payload);
+    }
+    /**
+     * Request old reactions
+     *
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID
+     */
+    requestOldReactions(threadType, lastMsgId = null) {
+        const payload = {
+            version: 1,
+            cmd: threadType === Enum.ThreadType.User ? 610 : 611,
+            subCmd: 1,
+            data: { first: true, lastId: lastMsgId, preIds: [] },
+        };
+        this.sendWs(payload);
+    }
+    reset() {
+        this.ws = null;
+        this.cipherKey = undefined;
+        if (this.pingInterval)
+            clearInterval(this.pingInterval);
+        if (this.watchdogTimeout)
+            clearTimeout(this.watchdogTimeout);
+    }
+}
+function getHeader(buffer) {
+    if (buffer.byteLength < 4) {
+        throw new ZaloApiError.ZaloApiError("Invalid header");
+    }
+    return [buffer[0], buffer.readUInt16LE(1), buffer[3]];
+}
+
+exports.Listener = Listener;

package/dist/cjs/realtime/types.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+exports.CloseReason = void 0;
+(function (CloseReason) {
+    CloseReason[CloseReason["ManualClosure"] = 1000] = "ManualClosure";
+    CloseReason[CloseReason["AbnormalClosure"] = 1006] = "AbnormalClosure";
+    CloseReason[CloseReason["DuplicateConnection"] = 3000] = "DuplicateConnection";
+    CloseReason[CloseReason["KickConnection"] = 3003] = "KickConnection";
+})(exports.CloseReason || (exports.CloseReason = {}));

package/dist/cjs/update.cjs

@@ -2,27 +2,30 @@
 
 var semver = require('semver');
 var utils = require('./utils.cjs');
+var protocol = require('./constants/protocol.cjs');
+var domains = require('./constants/domains.cjs');
 
-const VERSION = "2.2.7";
-const NPM_REGISTRY = "https://registry.npmjs.org/@softtynet/zca-js";
+const VERSION = protocol.ZALO_PROTOCOL.SDK_VERSION;
+const NPM_REGISTRY = domains.ZALO_DOMAINS.NPM_REGISTRY;
 async function checkUpdate(ctx) {
-    var _a, _b, _c;
     if (!ctx.options.checkUpdate)
         return;
-    const _options = Object.assign({}, (utils.isBun
-        ? {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            proxy: (_b = (_a = ctx.options.agent) === null || _a === void 0 ? void 0 : _a.proxy) === null || _b === void 0 ? void 0 : _b.href,
-        }
-        : { agent: ctx.options.agent }));
+    const _options = {
+        ...(utils.isBun
+            ? {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                proxy: ctx.options.agent?.proxy?.href,
+            }
+            : { agent: ctx.options.agent }),
+    };
     const response = await ctx.options.polyfill(NPM_REGISTRY, _options).catch(() => null);
     if (!response || !response.ok)
         return;
     const data = await response.json().catch(() => null);
     if (!data)
         return;
-    const latestVersion = (_c = data["dist-tags"]) === null || _c === void 0 ? void 0 : _c.latest;
+    const latestVersion = data["dist-tags"]?.latest;
     if (!latestVersion)
         return;
     if (semver.compare(VERSION, latestVersion) === -1) {