@shenira/baileysx 7.0.4

package/lib/Socket/socket.js

@@ -0,0 +1,727 @@
+"use strict";
+const boom_1 = require("@hapi/boom");
+const crypto_1 = require("crypto");
+const url_1 = require("url");
+const util_1 = require("util");
+const WAProto_1 = require("../../WAProto");
+const Defaults_1 = require("../Defaults");
+const Types_1 = require("../Types");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const Client_1 = require("./Client");
+
+const makeSocket = (config) => {
+    const {
+        waWebSocketUrl,
+        connectTimeoutMs,
+        logger,
+        keepAliveIntervalMs,
+        browser,
+        authState,
+        printQRInTerminal,
+        defaultQueryTimeoutMs,
+        transactionOpts,
+        qrTimeout,
+        makeSignalRepository
+    } = config;
+
+    const url = typeof waWebSocketUrl === 'string' 
+        ? new url_1.URL(waWebSocketUrl) 
+        : waWebSocketUrl;
+
+    // Validasi URL
+    if (config.rejectUnauthorized || url.protocol === 'http:') {
+        throw new boom_1.Boom('Invalid WebSocket URL', { 
+            statusCode: Types_1.DisconnectReason.badSession 
+        });
+    }
+
+    // Tambahkan auth state ke URL jika ada
+    if (url.protocol === 'ws:' && authState?.creds?.deviceSecret) {
+        url.searchParams.set('ED', authState.creds.deviceSecret.toString('base64'));
+    }
+
+    // Inisialisasi WebSocket
+    const ws = new Client_1.WebSocketClient(url, config);
+    ws.connect();
+
+    // Event emitter
+    const ev = Utils_1.makeEventEmitter(logger);
+    
+    // Generate ephemeral key pair untuk noise handshake
+    const ephemeralKeyPair = Utils_1.Curve.generateKeyPair();
+    
+    // Inisialisasi noise protocol
+    const noise = Utils_1.makeNoiseHandler({
+        ephemeralKeyPair,
+        staticKeyPairs: Defaults_1.KEY_BUNDLE_TYPE,
+        logger,
+        deviceSecret: authState?.creds?.deviceSecret
+    });
+
+    const { creds } = authState;
+    const keys = Utils_1.makeKeyStore(authState.keys, logger, transactionOpts);
+    const signalRepository = makeSignalRepository({ creds, keys });
+
+    let lastDateRecv;
+    let epoch = 1;
+    let keepAliveReq;
+    let qrTimer;
+    let closed = false;
+
+    // Generate unique tag ID untuk message
+    const uqTagId = Utils_1.generateMessageTag();
+    const generateMessageTag = () => {
+        return `${uqTagId}${epoch++}`;
+    };
+
+    // Promisify websocket send
+    const sendPromise = util_1.promisify(ws.send);
+    
+    const sendRawMessage = async (data) => {
+        if (!ws.isOpen) {
+            throw new boom_1.Boom('Connection closed', { 
+                statusCode: Types_1.DisconnectReason.connectionClosed 
+            });
+        }
+        
+        const bytes = noise.encodeFrame(data);
+        
+        await Utils_1.promiseWithTimeout(connectTimeoutMs, async (resolve, reject) => {
+            try {
+                await sendPromise.call(ws, bytes);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    };
+
+    const sendNode = (frame) => {
+        if (logger.level === 'trace') {
+            logger.trace({
+                node: WABinary_1.getBinaryNodeString(frame),
+                from: 'sendNode'
+            });
+        }
+        
+        const buff = WABinary_1.encodeBinaryNode(frame);
+        return sendRawMessage(buff);
+    };
+
+    const onUnexpectedError = (err, msg) => {
+        logger.warn({ err }, `'${msg}' errored`);
+        
+        const message = (err && (err.message || err.reason || String(err))).toLowerCase();
+        
+        if (message.includes('pre-key') || 
+            message.includes('session') && message.includes('404')) {
+            try {
+                uploadPreKeysToServerIfRequired(true).catch(e => {
+                    return logger.warn({ e }, 'failed to upload prekeys');
+                });
+            } catch (_e) {}
+        }
+        
+        if (message.includes('rate-overlimit') || message.includes('rate-overlimit')) {
+            const wait = Math.min(30000, config.retryRequestDelayMs || 5000);
+            logger.warn({ wait }, 'rate limiting hit, waiting...');
+            setTimeout(() => {}, wait);
+        }
+    };
+
+    const awaitNextMessage = async (sendMsg) => {
+        if (!ws.isOpen) {
+            throw new boom_1.Boom('Connection not open', {
+                statusCode: Types_1.DisconnectReason.connectionClosed
+            });
+        }
+        
+        let onOpen, onClose;
+        
+        const result = Utils_1.promiseWithTimeout(
+            connectTimeoutMs,
+            (resolve, reject) => {
+                onOpen = resolve;
+                onClose = mapWebSocketError(reject);
+                ws.on('open', onOpen);
+                ws.on('close', onClose);
+                ws.on('error', onClose);
+            }
+        ).finally(() => {
+            ws.off('open', onOpen);
+            ws.off('close', onClose);
+            ws.off('error', onClose);
+        });
+        
+        if (sendMsg) {
+            sendRawMessage(sendMsg).catch(onClose);
+        }
+        
+        return result;
+    };
+
+    const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
+        let onRecv, onErr;
+        
+        try {
+            const result = await Utils_1.promiseWithTimeout(
+                timeoutMs,
+                (resolve, reject) => {
+                    onRecv = resolve;
+                    onErr = (err) => {
+                        reject(err || new boom_1.Boom('Timed out', {
+                            statusCode: Types_1.DisconnectReason.timedOut
+                        }));
+                    };
+                    
+                    ws.on(`response:${msgId}`, onRecv);
+                    ws.on('close', onErr);
+                    ws.on('error', onErr);
+                }
+            );
+            
+            return result;
+        } finally {
+            ws.off(`response:${msgId}`, onRecv);
+            ws.off('close', onErr);
+            ws.off('error', onErr);
+        }
+    };
+
+    const query = async (node, timeoutMs) => {
+        if (!node.attrs.id) {
+            node.attrs.id = generateMessageTag();
+        }
+        
+        const msgId = node.attrs.id;
+        const [result] = await Promise.all([
+            waitForMessage(msgId, timeoutMs),
+            sendNode(node)
+        ]);
+        
+        if ('error' in result) {
+            WABinary_1.assertNodeErrorFree(result);
+        }
+        
+        return result;
+    };
+
+    const validateConnection = async () => {
+        // Buat hello message untuk handshake
+        let helloMsg = {
+            clientHello: { 
+                ephemeral: ephemeralKeyPair.public 
+            }
+        };
+        
+        helloMsg = WAProto_1.proto.HandshakeMessage.ClientHello.encode(helloMsg);
+        logger.trace({ browser, helloMsg }, 'sending client hello');
+        
+        const init = WAProto_1.proto.HandshakeMessage.ClientHello.encode(helloMsg).finish();
+        const result = await awaitNextMessage(init);
+        const handshake = WAProto_1.proto.HandshakeMessage.decode(result);
+        
+        logger.debug({ handshake }, 'received handshake');
+        
+        const keyEnc = await noise.processHandshake(handshake, creds.signedKeyPair);
+        
+        let node;
+        
+        if (!creds.me) {
+            node = Utils_1.newLoginPayload(creds, config);
+            logger.debug({ node }, 'sending login payload');
+        } else {
+            node = Utils_1.newRegisteredPayload(creds.me.id, config);
+            logger.debug({ node }, 'sending registered payload');
+        }
+        
+        const payloadEnc = noise.encrypt(
+            WAProto_1.proto.HandshakeMessage.ClientFinish.encode(node).finish()
+        );
+        
+        await sendRawMessage(
+            WAProto_1.proto.HandshakeMessage.encode({
+                clientFinish: {
+                    key: keyEnc,
+                    payload: payloadEnc
+                }
+            }).finish()
+        );
+        
+        noise.finishInit();
+        startKeepAliveRequest();
+    };
+
+    const getAvailablePreKeysOnServer = async () => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                id: generateMessageTag(),
+                xmlns: 'encrypt',
+                type: 'get',
+                to: WABinary_1.S_WHATSAPP_NET
+            },
+            content: [
+                { tag: 'key', attrs: {} }
+            ]
+        });
+        
+        const countChild = WABinary_1.getBinaryNodeChild(result, 'key');
+        return +countChild.attrs.count;
+    };
+
+    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT) => {
+        await keys.transaction(async () => {
+            logger.debug({ count }, 'uploading pre keys');
+            
+            const { update, node } = await Utils_1.generatePreKeys({
+                creds,
+                keys
+            }, count);
+            
+            await query(node);
+            ev.emit('creds.update', update);
+            logger.debug({ count }, 'pre keys uploaded');
+        });
+    };
+
+    const uploadPreKeysToServerIfRequired = async () => {
+        const preKeyCount = await getAvailablePreKeysOnServer();
+        logger.debug(`${preKeyCount} pre keys available on server`);
+        
+        if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
+            await uploadPreKeys();
+        }
+    };
+
+    const onMessageReceived = (data) => {
+        noise.processIncomingData(data, (frame) => {
+            let anyTriggered = false;
+            anyTriggered = ws.emit('frame', frame);
+            
+            if (!(frame instanceof Uint8Array)) {
+                const msgId = frame.attrs?.id;
+                
+                if (logger.level === 'silly') {
+                    logger.silly({
+                        node: WABinary_1.getBinaryNodeString(frame),
+                        from: 'onMessageReceived'
+                    });
+                }
+                
+                anyTriggered = ws.emit(`response:${Defaults_1.DEFAULT_ORIGIN}${msgId}`, frame) || anyTriggered;
+                
+                const l0 = frame.tag;
+                const l1 = frame.attrs || {};
+                const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : '';
+                
+                for (const key of Object.keys(l1)) {
+                    anyTriggered = ws.emit(`${Defaults_1.DEFAULT_ORIGIN}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
+                    anyTriggered = ws.emit(`${Defaults_1.DEFAULT_ORIGIN}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
+                    anyTriggered = ws.emit(`${Defaults_1.DEFAULT_ORIGIN}${l0},${key}`, frame) || anyTriggered;
+                }
+                
+                anyTriggered = ws.emit(`${Defaults_1.DEFAULT_ORIGIN}${l0},,${l2}`, frame) || anyTriggered;
+                anyTriggered = ws.emit(`${Defaults_1.DEFAULT_ORIGIN}${l0}`, frame) || anyTriggered;
+                
+                if (!anyTriggered && logger.level === 'silly') {
+                    logger.silly({
+                        unhandled: true,
+                        msgId,
+                        triggered: false,
+                        frame
+                    }, 'unhandled message');
+                }
+            }
+        });
+    };
+
+    const end = (error) => {
+        if (closed) {
+            logger.warn({ error: error?.message }, 'end already closed');
+            return;
+        }
+        
+        closed = true;
+        logger.debug({ error: error?.message }, error ? 'socket errored' : 'socket ended');
+        
+        clearInterval(keepAliveReq);
+        clearTimeout(qrTimer);
+        ws.removeAllListeners('open');
+        ws.removeAllListeners('close');
+        ws.removeAllListeners('error');
+        ws.removeAllListeners('frame');
+        
+        if (!ws.isClosed && !ws.isClosing) {
+            try {
+                ws.terminate();
+            } catch (_a) {}
+        }
+        
+        ev.emit('connection.update', {
+            connection: 'close',
+            lastDisconnect: { error, date: new Date }
+        });
+        ev.removeAllListeners('connection.update');
+    };
+
+    const waitForSocketOpen = async () => {
+        if (ws.isOpen) {
+            return;
+        }
+        
+        if (ws.isClosing || ws.isClosed) {
+            throw new boom_1.Boom('Connection closed', {
+                statusCode: Types_1.DisconnectReason.connectionClosed
+            });
+        }
+        
+        let onOpen, onClose;
+        
+        await new Promise((resolve, reject) => {
+            onOpen = () => { return resolve(true); };
+            onClose = mapWebSocketError(reject);
+            
+            ws.on('open', onOpen);
+            ws.on('close', onClose);
+            ws.on('error', onClose);
+        }).finally(() => {
+            ws.off('open', onOpen);
+            ws.off('close', onClose);
+            ws.off('error', onClose);
+        });
+    };
+
+    const startKeepAliveRequest = () => {
+        return keepAliveReq = setInterval(() => {
+            if (!lastDateRecv) {
+                lastDateRecv = new Date();
+            }
+            
+            const diff = Date.now() - lastDateRecv.getTime();
+            
+            if (diff > keepAliveIntervalMs + 5000) {
+                end(new boom_1.Boom('Keep alive timeout', {
+                    statusCode: Types_1.DisconnectReason.connectionLost
+                }));
+            } else {
+                if (ws.isOpen) {
+                    query({
+                        tag: 'iq',
+                        attrs: {
+                            id: generateMessageTag(),
+                            to: WABinary_1.S_WHATSAPP_NET,
+                            type: 'get',
+                            xmlns: 'w:keepalive'
+                        },
+                        content: [
+                            { tag: 'pong', attrs: {} }
+                        ]
+                    }).catch(err => {
+                        logger.warn({ error: err.message }, 'keep alive failed');
+                    });
+                } else {
+                    logger.debug('keep alive skipped, socket closed');
+                }
+            }
+        }, keepAliveIntervalMs);
+    };
+
+    const sendPassiveIq = (tag) => {
+        return query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'passive',
+                xml: 'passive'
+            },
+            content: [
+                { tag: tag, attrs: {} }
+            ]
+        });
+    };
+
+    const logout = async (msg) => {
+        const jid = authState.creds?.me?.id;
+        
+        if (jid) {
+            await sendNode({
+                tag: 'iq',
+                attrs: {
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'set',
+                    id: generateMessageTag(),
+                    xmlns: 'md'
+                },
+                content: [{
+                    tag: 'remove-companion-device',
+                    attrs: {
+                        jid: jid,
+                        reason: 'user_initiated'
+                    }
+                }]
+            });
+        }
+        
+        end(new boom_1.Boom(msg || 'logout', {
+            statusCode: Types_1.DisconnectReason.loggedOut
+        }));
+    };
+
+    const requestPairingCode = async (phoneNumber, pairKey) => {
+        if (pairKey) {
+            authState.creds.pairingKey = pairKey.publicKey();
+        } else {
+            authState.creds.pairingEphemeralKey = Utils_1.Curve.generateKeyPair(
+                crypto_1.randomBytes(32)
+            );
+        }
+        
+        authState.creds.me = {
+            id: WABinary_1.jidNormalizedUser(phoneNumber, 's.whatsapp.net'),
+            lid: '~'
+        };
+        
+        ev.emit('creds.update', authState.creds);
+        
+        await sendNode({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                id: generateMessageTag(),
+                xmlns: 'md'
+            },
+            content: [{
+                tag: 'pair-device',
+                attrs: {
+                    jid: authState.creds.me.id,
+                    ref: 'link_code',
+                    action: 'request'
+                },
+                content: [
+                    { tag: 'link_code', attrs: {}, content: await generatePairingKey() },
+                    { tag: 'ephemeral_key', attrs: {}, content: authState.creds.pairingEphemeralKey.public },
+                    { tag: 'companion_props', attrs: {}, content: Utils_1.encodeCompanionProps(browser[1]) },
+                    { tag: 'companion_os', attrs: {}, content: `${browser[1]} (${browser[0]})` },
+                    { tag: 'companion_version', attrs: {}, content: '0' }
+                ]
+            }]
+        });
+        
+        return authState.creds.pairingCode;
+    };
+
+    async function generatePairingKey() {
+        const salt = crypto_1.randomBytes(32);
+        const randomIv = crypto_1.randomBytes(16);
+        const key = await Utils_1.hkdf(
+            authState.creds.pairingEphemeralKey.sharedSecret,
+            salt
+        );
+        const ciphered = Utils_1.aes256GcmEncrypt(
+            authState.creds.pairingEphemeralKey.publicKey,
+            key,
+            randomIv
+        );
+        
+        return Buffer.concat([salt, randomIv, ciphered]);
+    }
+
+    const sendWAMBuffer = (wamBuffer) => {
+        return query({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                id: generateMessageTag(),
+                type: 'set',
+                xmlns: 'w:stats:wam'
+            },
+            content: [
+                { tag: 'wam', attrs: {}, content: wamBuffer }
+            ]
+        });
+    };
+
+    // Register event handlers
+    ws.on('message', onMessageReceived);
+    ws.on('open', async () => {
+        try {
+            await validateConnection();
+        } catch (err) {
+            logger.error({ err }, 'connection validation failed');
+            end(err);
+        }
+    });
+    
+    ws.on('error', mapWebSocketError(end));
+    ws.on('upgradeError', () => {
+        return end(new boom_1.Boom('Upgrade error', {
+            statusCode: Types_1.DisconnectReason.upgradeError
+        }));
+    });
+    
+    ws.on('close', () => {
+        return end(new boom_1.Boom('Connection closed', {
+            statusCode: Types_1.DisconnectReason.connectionClosed
+        }));
+    });
+    
+    ws.on('stream', async (stanza) => {
+        try {
+            await uploadPreKeysToServerIfRequired();
+            await sendPassiveIq('active');
+            logger.debug('stream resumed');
+            clearTimeout(qrTimer);
+            
+            ev.emit('creds.update', {
+                me: {
+                    ...authState.creds.me,
+                    lid: stanza.attrs.lid
+                }
+            });
+            
+            ev.emit('connection.update', {
+                connection: 'open'
+            });
+        } catch (err) {
+            logger.error({ err }, 'stream error');
+            end(err);
+        }
+    });
+    
+    ws.on('failure', (node) => {
+        logger.error({ node }, 'failure received');
+        const { reason, statusCode } = Utils_1.extractFailureReason(node);
+        end(new boom_1.Boom(`Failure: ${reason}`, {
+            statusCode: statusCode,
+            data: node
+        }));
+    });
+    
+    ws.on('streamError', (node) => {
+        const reason = +(node.attrs.code || 500);
+        end(new boom_1.Boom('Stream error', {
+            data: reason,
+            node: node.content
+        }));
+    });
+    
+    ws.on('timeout', () => {
+        end(new boom_1.Boom('WebSocket timeout', {
+            statusCode: Types_1.DisconnectReason.connectionTimeout
+        }));
+    });
+    
+    ws.on('ping', (node) => {
+        logger.debug('ping received', JSON.stringify(node));
+        sendNode({
+            tag: 'ib',
+            attrs: {},
+            content: [
+                { tag: 'd', attrs: { ping: 'pong' } }
+            ]
+        });
+    });
+    
+    ws.on('edge_routing', (node) => {
+        const edgeRoutingNode = WABinary_1.getBinaryNodeChild(node, 'edge_routing');
+        const routingInfo = WABinary_1.getBinaryNodeChild(edgeRoutingNode, 'routing_info');
+        
+        if (routingInfo?.content) {
+            authState.creds.routingInfo = Buffer.from(routingInfo.content);
+            ev.emit('creds.update', authState.creds);
+        }
+    });
+
+    let didStartBuffer = false;
+    
+    process.nextTick(() => {
+        if (creds?.me?.id) {
+            ev.flush();
+            didStartBuffer = true;
+        }
+        
+        ev.emit('connection.update', {
+            connection: 'connecting',
+            receivedPendingNotifications: false,
+            qr: null
+        });
+    });
+    
+    ws.on('stream:resumed', (node) => {
+        const child = WABinary_1.getBinaryNodeChild(node, 'stream');
+        const offlineNotifs = +((child?.attrs?.count) || 0);
+        
+        logger.debug(`stream resumed, pending notifs: ${offlineNotifs}`);
+        
+        if (didStartBuffer) {
+            ev.flush();
+            logger.debug('flushed buffer');
+        }
+        
+        ev.emit('connection.update', { receivedPendingNotifications: true });
+    });
+    
+    ev.on('creds.update', (update) => {
+        const name = update.me?.name;
+        
+        if (creds.me?.name !== name) {
+            logger.debug({ name }, 'sending pushname update');
+            sendNode({
+                tag: 'presence',
+                attrs: { name: name }
+            }).catch(err => {
+                logger.warn({ error: err.message }, 'failed to send pushname update');
+            });
+        }
+        
+        Object.assign(creds, update);
+    });
+
+    // Print QR di terminal jika diminta
+    if (printQRInTerminal) {
+        Utils_1.printQRIfNecessaryListener(ev, logger);
+    }
+
+    return {
+        type: 'md',
+        ws,
+        ev,
+        authState: { creds, keys },
+        signalRepository,
+        get user() {
+            return authState.creds.me;
+        },
+        generateMessageTag,
+        query,
+        waitForMessage,
+        waitForSocketOpen,
+        sendRawMessage,
+        sendNode,
+        logout,
+        end,
+        onUnexpectedError,
+        uploadPreKeys,
+        uploadPreKeysToServerIfRequired,
+        requestPairingCode,
+        createBufferedFunction: Utils_1.createBufferedFunction(ev),
+        sendWAMBuffer
+    };
+};
+
+exports.makeSocket = makeSocket;
+
+function mapWebSocketError(handler) {
+    return (error) => {
+        handler(new boom_1.Boom(
+            `WebSocket error: ${error?.message}`,
+            { 
+                statusCode: Utils_1.getErrorCode(error),
+                data: error 
+            }
+        ));
+    };
+}