zalo-toolkit 1.0.0

package/dist/cjs/utils.cjs

@@ -0,0 +1,320 @@
+'use strict';
+
+var cryptojs = require('crypto-js');
+require('json-bigint');
+var crypto = require('node:crypto');
+require('node:fs');
+require('node:path');
+require('pako');
+require('spark-md5');
+var ToughCookie = require('tough-cookie');
+require('sharp');
+var ZaloApiError = require('./Errors/ZaloApiError.cjs');
+require('./models/FriendEvent.cjs');
+require('./models/GroupEvent.cjs');
+
+// export const isBun = typeof Bun !== "undefined";
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+/**
+ * Get signed key for API requests.
+ *
+ * @param type
+ * @param params
+ * @returns MD5 hash
+ *
+ */
+function getSignKey(type, params) {
+    const n = [];
+    for (const s in params) {
+        if (hasOwn(params, s)) {
+            n.push(s);
+        }
+    }
+    n.sort();
+    let a = 'zsecure' + type;
+    for (let s = 0; s < n.length; s++)
+        a += params[n[s]];
+    return cryptojs.MD5(a).toString();
+}
+/**
+ *
+ * @param baseURL
+ * @param params
+ * @param apiVersion automatically add zalo api version to url params
+ * @returns
+ *
+ */
+function makeURL(ctx, baseURL, params = {}, apiVersion = true) {
+    const url = new URL(baseURL);
+    for (const key in params) {
+        if (hasOwn(params, key)) {
+            url.searchParams.append(key, params[key].toString());
+        }
+    }
+    if (apiVersion) {
+        if (!url.searchParams.has('zpw_ver'))
+            url.searchParams.set('zpw_ver', ctx.API_VERSION.toString());
+        if (!url.searchParams.has('zpw_type'))
+            url.searchParams.set('zpw_type', ctx.API_TYPE.toString());
+    }
+    return url.toString();
+}
+class ParamsEncryptor {
+    constructor({ type, imei, firstLaunchTime }) {
+        this.zcid = null;
+        this.enc_ver = 'v2';
+        this.zcid = null;
+        this.encryptKey = null;
+        this.createZcid(type, imei, firstLaunchTime);
+        this.zcid_ext = ParamsEncryptor.randomString();
+        this.createEncryptKey();
+    }
+    getEncryptKey() {
+        if (!this.encryptKey)
+            throw new ZaloApiError.ZaloApiError("getEncryptKey: didn't create encryptKey yet");
+        return this.encryptKey;
+    }
+    createZcid(type, imei, firstLaunchTime) {
+        if (!type || !imei || !firstLaunchTime)
+            throw new ZaloApiError.ZaloApiError('createZcid: missing params');
+        const msg = `${type},${imei},${firstLaunchTime}`;
+        const s = ParamsEncryptor.encodeAES('3FC4F0D2AB50057BCE0D90D9187A22B1', msg, 'hex', true);
+        this.zcid = s;
+    }
+    createEncryptKey(e = 0) {
+        const t = (e, t) => {
+            const { even: n } = ParamsEncryptor.processStr(e), { even: a, odd: s } = ParamsEncryptor.processStr(t);
+            if (!n || !a || !s)
+                return false;
+            const i = n.slice(0, 8).join('') + a.slice(0, 12).join('') + s.reverse().slice(0, 12).join('');
+            return (this.encryptKey = i), true;
+        };
+        if (!this.zcid || !this.zcid_ext)
+            throw new ZaloApiError.ZaloApiError('createEncryptKey: zcid or zcid_ext is null');
+        try {
+            const n = cryptojs.MD5(this.zcid_ext).toString().toUpperCase();
+            if (t(n, this.zcid) || !(e < 3))
+                return !1;
+            this.createEncryptKey(e + 1);
+        }
+        catch (_a) {
+            if (e < 3)
+                this.createEncryptKey(e + 1);
+        }
+        return true;
+    }
+    getParams() {
+        return this.zcid
+            ? {
+                zcid: this.zcid,
+                zcid_ext: this.zcid_ext,
+                enc_ver: this.enc_ver,
+            }
+            : null;
+    }
+    static processStr(e) {
+        if (!e || 'string' != typeof e)
+            return {
+                even: null,
+                odd: null,
+            };
+        const [t, n] = [...e].reduce((e, t, n) => (e[n % 2].push(t), e), [[], []]);
+        return {
+            even: t,
+            odd: n,
+        };
+    }
+    static randomString(e, t) {
+        const n = e || 6, a = t && e && t > e ? t : 12;
+        let s = Math.floor(Math.random() * (a - n + 1)) + n;
+        if (s > 12) {
+            let e = '';
+            for (; s > 0;) {
+                e += Math.random()
+                    .toString(16)
+                    .substr(2, s > 12 ? 12 : s);
+                s -= 12;
+            }
+            return e;
+        }
+        return Math.random().toString(16).substr(2, s);
+    }
+    static encodeAES(e, message, type, uppercase, s = 0) {
+        if (!message)
+            return null;
+        try {
+            {
+                const encoder = 'hex' == type ? cryptojs.enc.Hex : cryptojs.enc.Base64;
+                const key = cryptojs.enc.Utf8.parse(e);
+                const cfg = {
+                    words: [0, 0, 0, 0],
+                    sigBytes: 16,
+                };
+                const encrypted = cryptojs.AES.encrypt(message, key, {
+                    iv: cfg,
+                    mode: cryptojs.mode.CBC,
+                    padding: cryptojs.pad.Pkcs7,
+                }).ciphertext.toString(encoder);
+                return uppercase ? encrypted.toUpperCase() : encrypted;
+            }
+        }
+        catch (_a) {
+            return s < 3 ? ParamsEncryptor.encodeAES(e, message, type, uppercase, s + 1) : null;
+        }
+    }
+}
+function decryptResp(key, data) {
+    let n = null;
+    try {
+        n = decodeRespAES(key, data);
+        const parsed = JSON.parse(n);
+        return parsed;
+    }
+    catch (_a) {
+        return n;
+    }
+}
+function decodeRespAES(key, data) {
+    data = decodeURIComponent(data);
+    const parsedKey = cryptojs.enc.Utf8.parse(key);
+    const n = {
+        words: [0, 0, 0, 0],
+        sigBytes: 16,
+    };
+    return cryptojs.AES.decrypt({
+        ciphertext: cryptojs.enc.Base64.parse(data),
+    }, parsedKey, {
+        iv: n,
+        mode: cryptojs.mode.CBC,
+        padding: cryptojs.pad.Pkcs7,
+    }).toString(cryptojs.enc.Utf8);
+}
+async function getDefaultHeaders(ctx, origin = 'https://chat.zalo.me') {
+    if (!ctx.cookie)
+        throw new ZaloApiError.ZaloApiError('Cookie is not available');
+    if (!ctx.userAgent)
+        throw new ZaloApiError.ZaloApiError('User agent is not available');
+    return {
+        Accept: 'application/json, text/plain, */*',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'content-type': 'application/x-www-form-urlencoded',
+        Cookie: await ctx.cookie.getCookieString(origin),
+        Origin: 'https://chat.zalo.me',
+        Referer: 'https://chat.zalo.me/',
+        'User-Agent': ctx.userAgent,
+    };
+}
+async function request(ctx, url, options, raw = false) {
+    if (!ctx.cookie)
+        ctx.cookie = new ToughCookie.CookieJar();
+    const origin = new URL(url).origin;
+    const defaultHeaders = await getDefaultHeaders(ctx, origin);
+    if (!raw) {
+        if (options) {
+            options.headers = Object.assign(defaultHeaders, options.headers || {});
+        }
+        else
+            options = { headers: defaultHeaders };
+    }
+    const _options = Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), { agent: ctx.options.agent });
+    const response = await ctx.options.polyfill(url, _options);
+    const setCookieRaw = response.headers.get('set-cookie');
+    if (setCookieRaw && !raw) {
+        const splitCookies = setCookieRaw.split(', ');
+        for (const cookie of splitCookies) {
+            const parsed = ToughCookie.Cookie.parse(cookie);
+            try {
+                if (parsed)
+                    await ctx.cookie.setCookie(parsed, parsed.domain != 'zalo.me' ? `https://${parsed.domain}` : origin);
+            }
+            catch (error) {
+                logger(ctx).error(error);
+            }
+        }
+    }
+    const redirectURL = response.headers.get('location');
+    if (redirectURL) {
+        const redirectOptions = Object.assign({}, options);
+        redirectOptions.method = 'GET';
+        if (!raw) {
+            redirectOptions.headers = new Headers(redirectOptions.headers);
+            redirectOptions.headers.set('Referer', 'https://id.zalo.me/');
+        }
+        return await request(ctx, redirectURL, redirectOptions);
+    }
+    return response;
+}
+const logger = (ctx) => ({
+    verbose: (...args) => {
+        if (ctx.options.logging)
+            console.log('\x1b[35m🚀 VERBOSE\x1b[0m', ...args);
+    },
+    info: (...args) => {
+        if (ctx.options.logging)
+            console.log('\x1b[34mINFO\x1b[0m', ...args);
+    },
+    warn: (...args) => {
+        if (ctx.options.logging)
+            console.log('\x1b[33mWARN\x1b[0m', ...args);
+    },
+    error: (...args) => {
+        if (ctx.options.logging)
+            console.log('\x1b[31mERROR\x1b[0m', ...args);
+    },
+    success: (...args) => {
+        if (ctx.options.logging)
+            console.log('\x1b[32mSUCCESS\x1b[0m', ...args);
+    },
+    timestamp: (...args) => {
+        const now = new Date().toISOString();
+        if (ctx.options.logging)
+            console.log(`\x1b[90m[${now}]\x1b[0m`, ...args);
+    },
+});
+function generateZaloUUID(userAgent) {
+    return crypto.randomUUID() + '-' + cryptojs.MD5(userAgent).toString();
+}
+function getSecChUaPlatform(userAgent = '') {
+    const platformRegex = /\(([^)]+)\)/;
+    const platformMatch = userAgent.match(platformRegex);
+    // Kiểm tra và lấy nền tảng
+    if (platformMatch) {
+        const platform = platformMatch[1].toLowerCase();
+        let secChUaPlatform = '';
+        if (platform.includes('macintosh')) {
+            secChUaPlatform = '"macOS"';
+        }
+        else if (platform.includes('windows')) {
+            secChUaPlatform = '"Windows"';
+        }
+        else if (platform.includes('linux')) {
+            secChUaPlatform = '"Linux"';
+        }
+        else {
+            secChUaPlatform = '"Unknown"';
+        }
+        return secChUaPlatform;
+    }
+    return '"Unknown"';
+}
+function handleQueueStatus(queueStatus) {
+    for (const key in queueStatus) {
+        delete queueStatus[key].ids;
+    }
+    return queueStatus;
+}
+
+exports.ParamsEncryptor = ParamsEncryptor;
+exports.decryptResp = decryptResp;
+exports.generateZaloUUID = generateZaloUUID;
+exports.getDefaultHeaders = getDefaultHeaders;
+exports.getSecChUaPlatform = getSecChUaPlatform;
+exports.getSignKey = getSignKey;
+exports.handleQueueStatus = handleQueueStatus;
+exports.hasOwn = hasOwn;
+exports.logger = logger;
+exports.makeURL = makeURL;
+exports.request = request;

package/dist/cjs/zalo.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+var ToughCookie = require('tough-cookie');
+var login = require('./apis/login.cjs');
+var loginQR = require('./apis/loginQR.cjs');
+var context = require('./context.cjs');
+var ZaloApiError = require('./Errors/ZaloApiError.cjs');
+var utils = require('./utils.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var ToughCookie__namespace = /*#__PURE__*/_interopNamespaceDefault(ToughCookie);
+
+class Zalo {
+    constructor(options = {}) {
+        this.options = options;
+        this.enableEncryptParam = true;
+    }
+    parseCookies(cookie) {
+        var _a;
+        const cookieArr = Array.isArray(cookie) ? cookie : cookie.cookies;
+        cookieArr.forEach((e, i) => {
+            if (typeof e.domain == 'string' && e.domain.startsWith('.'))
+                cookieArr[i].domain = e.domain.slice(1);
+        });
+        const jar = new ToughCookie__namespace.CookieJar();
+        for (const each of cookieArr) {
+            try {
+                jar.setCookieSync((_a = ToughCookie__namespace.Cookie.fromJSON(Object.assign(Object.assign({}, each), { key: each.key || (each === null || each === void 0 ? void 0 : each.name) }))) !== null && _a !== void 0 ? _a : '', 'https://chat.zalo.me');
+            }
+            catch (error) {
+                utils.logger({
+                    options: {
+                        logging: this.options.logging,
+                    },
+                }).error('Failed to set cookie:', error);
+            }
+        }
+        return jar;
+    }
+    validateParams(credentials) {
+        if (!credentials.imei || !credentials.cookie || !credentials.userAgent) {
+            throw new ZaloApiError.ZaloApiError('Missing required params');
+        }
+    }
+    async loginCookie(props) {
+        const { ctx, credentials, sessionId, imei, getPreviousImei } = props;
+        this.validateParams(credentials);
+        ctx.imei = credentials.imei;
+        ctx.cookie = this.parseCookies(credentials.cookie);
+        ctx.userAgent = credentials.userAgent;
+        ctx.language = credentials.language || 'vi';
+        if (imei) {
+            ctx.imei = imei;
+        }
+        let serverInfo = await login.getServerInfo(ctx, this.enableEncryptParam).catch(() => null);
+        if (typeof getPreviousImei === 'function') {
+            const previousImei = await getPreviousImei(serverInfo);
+            ctx.imei = previousImei;
+            serverInfo = await login.getServerInfo(ctx, this.enableEncryptParam).catch(() => null);
+        }
+        const loginData = await login.login(ctx, this.enableEncryptParam);
+        const loginInfo = loginData === null || loginData === void 0 ? void 0 : loginData.data;
+        if (!loginData || !loginInfo || !serverInfo)
+            throw new ZaloApiError.ZaloApiError('Đăng nhập thất bại');
+        ctx.secretKey = loginInfo.zpw_enk;
+        ctx.uid = loginInfo.uid;
+        ctx.settings = serverInfo.setttings || serverInfo.settings;
+        ctx.extraVer = serverInfo.extra_ver;
+        ctx.loginInfo = loginInfo;
+        if (!context.isContextSession(ctx))
+            throw new ZaloApiError.ZaloApiError('Khởi tạo ngữ cảnh thất bại.');
+        utils.logger(ctx).info('Logged in as', loginInfo.uid);
+        return { ctx: ctx, loginInfo: loginInfo };
+    }
+    async generateQR(options) {
+        if (!options)
+            options = {};
+        if (!options.userAgent)
+            options.userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0';
+        if (!options.language)
+            options.language = 'vi';
+        const ctx = context.createContext(this.options.apiType, this.options.apiVersion);
+        Object.assign(ctx.options, this.options);
+        const resultQR = await loginQR.generateQR(ctx, options);
+        const serializedCookie = ctx.cookie.toJSON();
+        return { qrData: resultQR === null || resultQR === void 0 ? void 0 : resultQR.qrData, serializedCookie: serializedCookie, loginVersion: resultQR === null || resultQR === void 0 ? void 0 : resultQR.loginVersion };
+    }
+    async waitingScanQR(ctx, loginVersion, code) {
+        return await loginQR.waitingScan(ctx, loginVersion, code);
+    }
+    async waitingConfirm(props) {
+        const { ctx, loginVersion, code, sessionId, imei, getPreviousImei } = props;
+        const loginQRResult = await loginQR.handleWaitingConfirm(ctx, loginVersion, code);
+        if (!loginQRResult || !(ctx === null || ctx === void 0 ? void 0 : ctx.userAgent))
+            return null;
+        return this.loginCookie({
+            ctx: ctx,
+            credentials: {
+                cookie: loginQRResult.cookies,
+                imei: utils.generateZaloUUID(ctx.userAgent),
+                userAgent: ctx.userAgent,
+                language: ctx.language,
+            },
+            sessionId: sessionId,
+            imei: imei,
+            getPreviousImei: getPreviousImei,
+        });
+    }
+}
+
+exports.Zalo = Zalo;

package/dist/context.d.ts

@@ -0,0 +1,199 @@
+import type { Agent } from 'http';
+import type { CookieJar } from 'tough-cookie';
+type UploadEventData = {
+    fileUrl: string;
+    fileId: string;
+};
+export type UploadCallback = (data: UploadEventData) => unknown;
+export type ShareFileSettings = {
+    big_file_domain_list: string[];
+    max_size_share_file_v2: number;
+    max_size_share_file_v3: number;
+    file_upload_show_icon_1GB: boolean;
+    restricted_ext: string;
+    next_file_time: number;
+    max_file: number;
+    max_size_photo: number;
+    max_size_share_file: number;
+    max_size_resize_photo: number;
+    max_size_gif: number;
+    max_size_original_photo: number;
+    chunk_size_file: number;
+    restricted_ext_file: string[];
+};
+export type SocketSettings = {
+    rotate_error_codes: (number | string)[];
+    retries: {
+        [key: string]: {
+            max?: number;
+            times: number[] | number;
+        };
+    };
+    debug: {
+        enable: boolean;
+        skip_ping: boolean;
+        skip_msg: boolean;
+    };
+    ping_interval: number;
+    reset_endpoint: number;
+    queue_ctrl_actionid_map: {
+        '611_0': string;
+        '610_1': string;
+        '610_0': string;
+        '603_0': string;
+        '611_1': string;
+    };
+    close_and_retry_codes: number[];
+    max_msg_size: number;
+    enable_ctrl_socket: boolean;
+    reconnect_after_fallback: boolean;
+    enable_chat_socket: boolean;
+    submit_wss_log: boolean;
+    disable_lp: boolean;
+    offline_monitor: {
+        enable: boolean;
+    };
+    none_ids_queue?: string[];
+    ping_http_level?: number;
+    close_timeout?: number;
+    enable_fallback_lp: boolean;
+    retries_round_2: Record<string, any>;
+};
+export interface OnlineConfigs {
+    update_action_interval: number;
+    user_active_time: number;
+    enable_lost_focus: boolean;
+    is_enable_new: number;
+    enable_active_deactive_v2: boolean;
+    send_active_to_keep_live: boolean;
+}
+export type LoginInfo = {
+    [key: string]: any;
+    haspcclient: number;
+    public_ip: string;
+    language: string;
+    send2me_id: string;
+    zpw_service_map_v3: {
+        other_contact: string[];
+        chat_e2e: string[];
+        workspace: string[];
+        catalog: string[];
+        boards: string[];
+        downloadStickerUrl: string[];
+        sp_contact: string[];
+        zcloud_up_file: string[];
+        media_store_send2me: string[];
+        push_act: string[];
+        aext: string[];
+        zfamily: string[];
+        group_poll: string[];
+        group_cloud_message: string[];
+        media_store: string[];
+        file: string[];
+        auto_reply: string[];
+        sync_action: string[];
+        friendLan: string[];
+        friend: string[];
+        alias: string[];
+        zimsg: string[];
+        group_board: string[];
+        conversation: string[];
+        group: string[];
+        fallback_LP: string[];
+        friend_board: string[];
+        up_file: string[];
+        zavi: string[];
+        reaction: string[];
+        voice_call: string[];
+        profile: string[];
+        sticker: string[];
+        label: string[];
+        consent: string[];
+        zcloud: string[];
+        chat: string[];
+        todoUrl: string[];
+        recent_search: string[];
+        group_e2e: string[];
+        quick_message: string[];
+    };
+};
+export type ServerInfo = {
+    config_pages: {
+        zalo_page: string;
+    };
+};
+export type ExtraVer = {
+    phonebook: number;
+    conv_label: string;
+    friend: string;
+    ver_sticker_giphy_suggest: number;
+    ver_giphy_cate: number;
+    alias: string;
+    ver_sticker_cate_list: number;
+    block_friend: string;
+};
+export type ZPWServiceMap = LoginInfo['zpw_service_map_v3'];
+export type AppContextBase = {
+    uid: string;
+    imei: string;
+    cookie: CookieJar;
+    userAgent: string;
+    language: string;
+    secretKey: string | null;
+    zpwServiceMap: ZPWServiceMap;
+    settings: {
+        [key: string]: any;
+        features: {
+            [key: string]: any;
+            sharefile: ShareFileSettings;
+            socket: SocketSettings;
+            online_configs: OnlineConfigs;
+        };
+        keepalive: {
+            alway_keepalive: number;
+            keepalive_duration: number;
+            time_deactive: number;
+        };
+    };
+    loginInfo: LoginInfo;
+    extraVer: ExtraVer;
+};
+export type ImageMetadataGetterResponse = {
+    width: number;
+    height: number;
+    size: number;
+} | null;
+export type ImageMetadataGetter = (filePath: string) => Promise<ImageMetadataGetterResponse>;
+export type Options = {
+    selfListen: boolean;
+    checkUpdate: boolean;
+    logging: boolean;
+    apiType: number;
+    apiVersion: number;
+    agent?: Agent;
+    /**
+     * Optional fetch implementation for polyfills in non-standard environments.
+     * If using proxy, `node-fetch` is highly recommended.
+     */
+    polyfill: typeof fetch;
+    imageMetadataGetter?: ImageMetadataGetter;
+};
+export declare class CallbacksMap extends Map<string, UploadCallback> {
+    /**
+     * @param ttl Time to live in milliseconds. Default is 5 minutes.
+     */
+    set(key: string, value: UploadCallback, ttl?: number): this;
+}
+export type AppContextExtended = {
+    options: Options;
+    readonly API_TYPE: number;
+    readonly API_VERSION: number;
+};
+export type ContextBase = Partial<AppContextBase> & AppContextExtended;
+export declare const createContext: (apiType?: number, apiVersion?: number) => ContextBase;
+export type ContextSession = AppContextBase & AppContextExtended & {
+    secretKey: string;
+};
+export declare function isContextSession(ctx: ContextBase): ctx is ContextSession;
+export declare const MAX_MESSAGES_PER_SEND = 50;
+export {};

package/dist/context.js

@@ -0,0 +1,27 @@
+const _5_MINUTES = 5 * 60 * 1000;
+export class CallbacksMap extends Map {
+    /**
+     * @param ttl Time to live in milliseconds. Default is 5 minutes.
+     */
+    set(key, value, ttl = _5_MINUTES) {
+        setTimeout(() => {
+            this.delete(key);
+        }, ttl);
+        return super.set(key, value);
+    }
+}
+export const createContext = (apiType = 30, apiVersion = 665) => ({
+    API_TYPE: apiType,
+    API_VERSION: apiVersion,
+    options: {
+        selfListen: false,
+        checkUpdate: true,
+        logging: true,
+        polyfill: global.fetch,
+    },
+    secretKey: null,
+});
+export function isContextSession(ctx) {
+    return !!ctx.secretKey;
+}
+export const MAX_MESSAGES_PER_SEND = 50;

package/dist/core/enums/common.d.ts

@@ -0,0 +1,11 @@
+export declare enum AttachmentType {
+    FILE = "file",
+    IMAGE = "image",
+    GIF = "gif",
+    VIDEO = "video",
+    AUDIO = "audio",
+    STICKER = "sticker",
+    CALL = "call",
+    CARD = "card",
+    LINK = "link"
+}

package/dist/core/enums/common.js

@@ -0,0 +1,12 @@
+export var AttachmentType;
+(function (AttachmentType) {
+    AttachmentType["FILE"] = "file";
+    AttachmentType["IMAGE"] = "image";
+    AttachmentType["GIF"] = "gif";
+    AttachmentType["VIDEO"] = "video";
+    AttachmentType["AUDIO"] = "audio";
+    AttachmentType["STICKER"] = "sticker";
+    AttachmentType["CALL"] = "call";
+    AttachmentType["CARD"] = "card";
+    AttachmentType["LINK"] = "link";
+})(AttachmentType || (AttachmentType = {}));