@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Socket/groups.js

@@ -0,0 +1,345 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.extractGroupMetadata = exports.makeGroupsSocket = void 0
+const WAProto_1 = require('../../WAProto')
+const Types_1 = require('../Types')
+const Utils_1 = require('../Utils')
+const WABinary_1 = require('../WABinary')
+const chats_1 = require('./chats')
+const WAUSync_1 = require('../WAUSync')
+const makeGroupsSocket = (config) => {
+    const sock = (0, chats_1.makeChatsSocket)(config)
+    const { authState, ev, query, upsertMessage } = sock
+    const groupQuery = async (jid, type, content) =>
+        query({
+            tag: 'iq',
+            attrs: {
+                type,
+                xmlns: 'w:g2',
+                to: jid
+            },
+            content
+        })
+    const groupMetadata = async (jid) => {
+        const result = await groupQuery(jid, 'get', [
+            { tag: 'query', attrs: { request: 'interactive' } }
+        ])
+        return (0, exports.extractGroupMetadata)(result)
+    }
+    const groupFetchAllParticipating = async () => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: '@g.us',
+                xmlns: 'w:g2',
+                type: 'get'
+            },
+            content: [
+                {
+                    tag: 'participating',
+                    attrs: {},
+                    content: [
+                        { tag: 'participants', attrs: {} },
+                        { tag: 'description', attrs: {} }
+                    ]
+                }
+            ]
+        })
+        const data = {}
+        const groupsChild = (0, WABinary_1.getBinaryNodeChild)(result, 'groups')
+        if (groupsChild) {
+            const groups = (0, WABinary_1.getBinaryNodeChildren)(groupsChild, 'group')
+            for (const groupNode of groups) {
+                const meta = (0, exports.extractGroupMetadata)({
+                    tag: 'result',
+                    attrs: {},
+                    content: [groupNode]
+                })
+                data[meta.id] = meta
+            }
+        }
+        sock.ev.emit('groups.update', Object.values(data))
+        return data
+    }
+    sock.ws.on('CB:ib,,dirty', async (node) => {
+        const { attrs } = (0, WABinary_1.getBinaryNodeChild)(node, 'dirty')
+        if (attrs.type !== 'groups') {
+            return
+        }
+        await groupFetchAllParticipating()
+        await sock.cleanDirtyBits('groups')
+    })
+    return {
+        ...sock,
+        groupMetadata,
+        groupCreate: async (subject, participants) => {
+            const key = (0, Utils_1.generateMessageID)()
+            const result = await groupQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: {
+                        subject,
+                        key
+                    },
+                    content: participants.map((jid) => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ])
+            return (0, exports.extractGroupMetadata)(result)
+        },
+        groupLeave: async (id) => {
+            await groupQuery('@g.us', 'set', [
+                {
+                    tag: 'leave',
+                    attrs: {},
+                    content: [{ tag: 'group', attrs: { id } }]
+                }
+            ])
+        },
+        groupUpdateSubject: async (jid, subject) => {
+            await groupQuery(jid, 'set', [
+                {
+                    tag: 'subject',
+                    attrs: {},
+                    content: Buffer.from(subject, 'utf-8')
+                }
+            ])
+        },
+        groupRequestParticipantsList: async (jid) => {
+            const result = await groupQuery(jid, 'get', [
+                {
+                    tag: 'membership_approval_requests',
+                    attrs: {}
+                }
+            ])
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_approval_requests')
+            const participants = (0, WABinary_1.getBinaryNodeChildren)(
+                node,
+                'membership_approval_request'
+            )
+            return participants.map((v) => v.attrs)
+        },
+        groupRequestParticipantsUpdate: async (jid, participants, action) => {
+            const result = await groupQuery(jid, 'set', [
+                {
+                    tag: 'membership_requests_action',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: action,
+                            attrs: {},
+                            content: participants.map((jid) => ({
+                                tag: 'participant',
+                                attrs: { jid }
+                            }))
+                        }
+                    ]
+                }
+            ])
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_requests_action')
+            const nodeAction = (0, WABinary_1.getBinaryNodeChild)(node, action)
+            const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(
+                nodeAction,
+                'participant'
+            )
+            return participantsAffected.map((p) => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid }
+            })
+        },
+        groupParticipantsUpdate: async (jid, participants, action) => {
+            const result = await groupQuery(jid, 'set', [
+                {
+                    tag: action,
+                    attrs: {},
+                    content: participants.map((jid) => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ])
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, action)
+            const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(node, 'participant')
+            return participantsAffected.map((p) => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p }
+            })
+        },
+        groupUpdateDescription: async (jid, description) => {
+            var _a
+            const metadata = await groupMetadata(jid)
+            const prev = (_a = metadata.descId) !== null && _a !== void 0 ? _a : null
+            await groupQuery(jid, 'set', [
+                {
+                    tag: 'description',
+                    attrs: {
+                        ...(description
+                            ? { id: (0, Utils_1.generateMessageID)() }
+                            : { delete: 'true' }),
+                        ...(prev ? { prev } : {})
+                    },
+                    content: description
+                        ? [{ tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }]
+                        : undefined
+                }
+            ])
+        },
+        groupInviteCode: async (jid) => {
+            const result = await groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }])
+            const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite')
+            return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code
+        },
+        groupRevokeInvite: async (jid) => {
+            const result = await groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }])
+            const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite')
+            return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code
+        },
+        groupAcceptInvite: async (code) => {
+            const results = await groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }])
+            const result = (0, WABinary_1.getBinaryNodeChild)(results, 'group')
+            return result === null || result === void 0 ? void 0 : result.attrs.jid
+        },
+        /**
+         * accept a GroupInviteMessage
+         * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
+         * @param inviteMessage the message to accept
+         */
+        groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
+            key = typeof key === 'string' ? { remoteJid: key } : key
+            const results = await groupQuery(inviteMessage.groupJid, 'set', [
+                {
+                    tag: 'accept',
+                    attrs: {
+                        code: inviteMessage.inviteCode,
+                        expiration: inviteMessage.inviteExpiration.toString(),
+                        admin: key.remoteJid
+                    }
+                }
+            ])
+            // if we have the full message key
+            // update the invite message to be expired
+            if (key.id) {
+                // create new invite message that is expired
+                inviteMessage = WAProto_1.proto.Message.GroupInviteMessage.fromObject(inviteMessage)
+                inviteMessage.inviteExpiration = 0
+                inviteMessage.inviteCode = ''
+                ev.emit('messages.update', [
+                    {
+                        key,
+                        update: {
+                            message: {
+                                groupInviteMessage: inviteMessage
+                            }
+                        }
+                    }
+                ])
+            }
+            // generate the group add message
+            await upsertMessage(
+                {
+                    key: {
+                        remoteJid: inviteMessage.groupJid,
+                        id: (0, Utils_1.generateMessageID)(),
+                        fromMe: false,
+                        participant: key.remoteJid
+                    },
+                    messageStubType: Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD,
+                    messageStubParameters: [authState.creds.me.id],
+                    participant: key.remoteJid,
+                    messageTimestamp: (0, Utils_1.unixTimestampSeconds)()
+                },
+                'notify'
+            )
+            return results.attrs.from
+        }),
+        groupGetInviteInfo: async (code) => {
+            const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }])
+            return (0, exports.extractGroupMetadata)(results)
+        },
+        groupToggleEphemeral: async (jid, ephemeralExpiration) => {
+            const content = ephemeralExpiration
+                ? { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } }
+                : { tag: 'not_ephemeral', attrs: {} }
+            await groupQuery(jid, 'set', [content])
+        },
+        groupSettingUpdate: async (jid, setting) => {
+            await groupQuery(jid, 'set', [{ tag: setting, attrs: {} }])
+        },
+        groupMemberAddMode: async (jid, mode) => {
+            await groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }])
+        },
+        groupJoinApprovalMode: async (jid, mode) => {
+            await groupQuery(jid, 'set', [
+                {
+                    tag: 'membership_approval_mode',
+                    attrs: {},
+                    content: [{ tag: 'group_join', attrs: { state: mode } }]
+                }
+            ])
+        },
+        groupFetchAllParticipating
+    }
+}
+exports.makeGroupsSocket = makeGroupsSocket
+const extractGroupMetadata = (result) => {
+    var _a, _b
+    const group = WABinary_1.getBinaryNodeChild(result, 'group')
+    const descChild = WABinary_1.getBinaryNodeChild(group, 'description')
+    let desc
+    let descId
+    let descOwner
+    let descOwnerLid
+    let descTime
+    if (descChild) {
+        desc = WABinary_1.getBinaryNodeChildString(descChild, 'body')
+        descOwner = WABinary_1.jidNormalizedUser(
+            descChild.attrs.participant_pn || descChild.attrs.participant
+        )
+        if (group.attrs.addressing_mode === 'lid') {
+            descOwnerLid = WABinary_1.jidNormalizedUser(descChild.attrs.participant)
+        }
+        descId = descChild.attrs.id
+        descTime = descChild.attrs.t ? +descChild.attrs.t : undefined
+    }
+    const groupSize = group.attrs.size ? Number(group.attrs.size) : undefined
+    const groupId = group.attrs.id.includes('@')
+        ? group.attrs.id
+        : (0, WABinary_1.jidEncode)(group.attrs.id, 'g.us')
+    const eph = WABinary_1.getBinaryNodeChild(group, 'ephemeral')?.attrs.expiration
+    const memberAddMode =
+        WABinary_1.getBinaryNodeChildString(group, 'member_add_mode') === 'all_member_add'
+    const metadata = {
+        id: groupId,
+        addressingMode: group.attrs.addressing_mode,
+        subject: group.attrs.subject,
+        subjectOwner: WABinary_1.jidNormalizedUser(group.attrs.s_o_pn || group.attrs.s_o),
+        ...(group.attrs.addressing_mode === 'lid'
+            ? { subjectOwnerLid: WABinary_1.jidNormalizedUser(group.attrs.s_o) }
+            : {}),
+        subjectTime: group.attrs.s_t ? +group.attrs.s_t : undefined,
+        size: groupSize || WABinary_1.getBinaryNodeChildren(group, 'participant').length,
+        creation: group.attrs.creation ? +group.attrs.creation : undefined,
+        owner: WABinary_1.jidNormalizedUser(group.attrs.creator_pn || group.attrs.creator),
+        ...(group.attrs.addressing_mode === 'lid'
+            ? { ownerLid: WABinary_1.jidNormalizedUser(group.attrs.creator) }
+            : {}),
+        descOwner,
+        descOwnerLid,
+        restrict: !!WABinary_1.getBinaryNodeChild(group, 'locked'),
+        announce: !!WABinary_1.getBinaryNodeChild(group, 'announcement'),
+        isCommunity: !!WABinary_1.getBinaryNodeChild(group, 'parent'),
+        isCommunityAnnounce: !!WABinary_1.getBinaryNodeChild(group, 'default_sub_group'),
+        joinApprovalMode: !!WABinary_1.getBinaryNodeChild(group, 'membership_approval_mode'),
+        memberAddMode,
+        participants: WABinary_1.getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
+            return {
+                id: attrs.jid,
+                jid: attrs.phone_number || attrs.jid,
+                admin: attrs.type || null
+            }
+        }),
+        ephemeralDuration: eph ? +eph : undefined
+    }
+    return metadata
+}
+exports.extractGroupMetadata = extractGroupMetadata

package/lib/Socket/index.js

@@ -0,0 +1,22 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+const Defaults_1 = require('../Defaults')
+const registration_1 = require('./registration')
+const lid_mapping_1 = require('./lid-mapping')
+// export the last socket layer
+const makeWASocket = (config) => {
+    const fullConfig = {
+        ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
+        ...config
+    }
+    const sock = (0, registration_1.makeRegistrationSocket)(fullConfig)
+    // LID/PN helpers are lazy (nothing runs until called); enableLidMapping only adds passive learning
+    try {
+        return (0, lid_mapping_1.attachLidMapping)(sock, fullConfig)
+    } catch (err) {
+        fullConfig.logger?.warn?.({ err }, 'LID mapping helpers unavailable')
+        return sock
+    }
+}
+exports.default = makeWASocket
+exports.makeWASocket = makeWASocket

package/lib/Socket/interop.js

@@ -0,0 +1,265 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeInteropSocket = void 0
+
+const { getBinaryNodeChild, getBinaryNodeChildren, S_WHATSAPP_NET } = require('../WABinary')
+const { executeWMexQuery } = require('./mex')
+
+const INTEROP_MEX_QUERY_IDS = {
+    CREATE_GROUP: '25726817620301611',
+    LEAVE_GROUP: '25346167795013271',
+    ADD_PARTICIPANTS: '25732168276369451',
+    QUERY_GROUP_INFO: '32734144032867938',
+    PRIVACY_SETTINGS_QUERY: '24849123668112654',
+    PRIVACY_SETTINGS_UPDATE: '25421856497452763',
+    PRIVACY_SETTINGS_WITH_CONTACT_LIST: '24913399124998598'
+}
+
+const INTEGRATOR_BIRDYCHAT = 12
+const INTEGRATOR_HAIKET = 13
+
+const makeInteropSocket = (sock) => {
+    const { query, generateMessageTag, logger, signalRepository } = sock
+    const mexQuery = (variables, queryId, dataPath) =>
+        executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
+
+    const fetchIntegrators = async () => {
+        const result = await query({
+            tag: 'iq',
+            attrs: { type: 'get', xmlns: 'w:interop', to: S_WHATSAPP_NET },
+            content: [{ tag: 'integrator', attrs: { fetch: 'all' } }]
+        })
+        const listNode = getBinaryNodeChild(result, 'integrator_list')
+        if (!listNode) return []
+        const globalOptedIn = listNode.attrs?.opted_in === 'true'
+        return getBinaryNodeChildren(listNode, 'integrator').map((node) => {
+            const featuresNode = getBinaryNodeChild(node, 'features')
+            return {
+                id: parseInt(node.attrs.id, 10),
+                name: node.attrs.name,
+                status: node.attrs.status,
+                icon: node.attrs.icon,
+                identifierType: node.attrs.identifier_type,
+                optedIn: node.attrs.opted_in === 'true' || globalOptedIn,
+                features: { groupMessaging: featuresNode?.attrs?.group_messaging === 'true' }
+            }
+        })
+    }
+
+    const acceptInteropTOS = async () => {
+        const sendTOS = async (id, result) =>
+            await query({
+                tag: 'iq',
+                attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'tos' },
+                content: [{ tag: 'trackable', attrs: { id, result } }]
+            })
+        await sendTOS('20240306', '105')
+        await sendTOS('20240306', '160')
+    }
+
+    const optInIntegrators = async (integratorIds = [INTEGRATOR_BIRDYCHAT, INTEGRATOR_HAIKET]) => {
+        await query({
+            tag: 'iq',
+            attrs: { type: 'set', xmlns: 'w:interop', to: S_WHATSAPP_NET },
+            content: [
+                {
+                    tag: 'opt_integrators',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'integrator_list',
+                            attrs: {},
+                            content: integratorIds.map((id) => ({
+                                tag: 'integrator',
+                                attrs: { id: id.toString() }
+                            }))
+                        }
+                    ]
+                }
+            ]
+        })
+    }
+
+    const optOutIntegrators = async (integratorIds = [INTEGRATOR_BIRDYCHAT, INTEGRATOR_HAIKET]) => {
+        await query({
+            tag: 'iq',
+            attrs: { type: 'set', xmlns: 'w:interop', to: S_WHATSAPP_NET },
+            content: [
+                {
+                    tag: 'opt_out_integrators',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'integrator_list',
+                            attrs: {},
+                            content: integratorIds.map((id) => ({
+                                tag: 'integrator',
+                                attrs: { id: id.toString() }
+                            }))
+                        }
+                    ]
+                }
+            ]
+        })
+    }
+
+    const resolveInteropUsers = async (users) => {
+        if (!users || users.length === 0) return []
+        const result = await query({
+            tag: 'iq',
+            attrs: { type: 'get', xmlns: 'w:interop', to: S_WHATSAPP_NET },
+            content: [
+                {
+                    tag: 'users',
+                    attrs: {},
+                    content: users.map(({ externalId, integratorId }) => ({
+                        tag: 'user',
+                        attrs: { external_id: externalId, integrator_id: integratorId.toString() }
+                    }))
+                }
+            ]
+        })
+        const usersNode = getBinaryNodeChild(result, 'users')
+        if (!usersNode) return []
+        return getBinaryNodeChildren(usersNode, 'user').map((userNode) => {
+            const errorNode = getBinaryNodeChild(userNode, 'error')
+            if (errorNode)
+                return {
+                    externalId: userNode.attrs.external_id,
+                    integratorId: parseInt(userNode.attrs.integrator_id, 10),
+                    error: { code: parseInt(errorNode.attrs.code, 10), text: errorNode.attrs.text }
+                }
+            return {
+                jid: userNode.attrs.jid,
+                externalId: userNode.attrs.external_id,
+                normalizedExternalId: userNode.attrs.normalized_external_id,
+                integratorId: parseInt(userNode.attrs.integrator_id, 10)
+            }
+        })
+    }
+
+    const resolveInteropUser = async (externalId, integratorId) => {
+        const results = await resolveInteropUsers([{ externalId, integratorId }])
+        return results[0] ?? null
+    }
+
+    const blockInteropUser = async (jid) =>
+        await query({
+            tag: 'iq',
+            attrs: { type: 'set', xmlns: 'w:interop', to: S_WHATSAPP_NET },
+            content: [
+                {
+                    tag: 'blocklist',
+                    attrs: {},
+                    content: [{ tag: 'item', attrs: { action: 'block', jid } }]
+                }
+            ]
+        })
+    const unblockInteropUser = async (jid) =>
+        await query({
+            tag: 'iq',
+            attrs: { type: 'set', xmlns: 'w:interop', to: S_WHATSAPP_NET },
+            content: [
+                {
+                    tag: 'blocklist',
+                    attrs: {},
+                    content: [{ tag: 'item', attrs: { action: 'unblock', jid } }]
+                }
+            ]
+        })
+
+    const initInterop = async () => {
+        let integrators
+        try {
+            integrators = await fetchIntegrators()
+        } catch (err) {
+            logger.warn({ err }, 'interop: failed to fetch integrators')
+            return []
+        }
+        const toOptIn = integrators.filter(
+            (i) => i.status === 'active' || i.status === 'onboarding'
+        )
+        if (toOptIn.length === 0) return integrators
+        try {
+            await acceptInteropTOS()
+        } catch (err) {
+            logger.warn({ err }, 'interop: failed to accept TOS')
+        }
+        try {
+            await optInIntegrators(toOptIn.map((i) => i.id))
+        } catch (err) {
+            logger.warn({ err }, 'interop: failed to opt-in integrators')
+        }
+        return integrators
+    }
+
+    const createInteropGroup = async (participants) =>
+        mexQuery(
+            { input: { participants: participants.map((jid) => ({ jid })) } },
+            INTEROP_MEX_QUERY_IDS.CREATE_GROUP,
+            'xwa2_interop_group_create'
+        )
+
+    const leaveInteropGroup = async (jids) => {
+        const ids = Array.isArray(jids) ? jids : [jids]
+        return mexQuery(
+            { input: { groups_to_leave: ids.map((jid) => ({ gid: jid.split('@')[0] })) } },
+            INTEROP_MEX_QUERY_IDS.LEAVE_GROUP,
+            'xwa2_interop_group_leave'
+        )
+    }
+
+    const addParticipantsToInteropGroup = async (groupJid, participants) =>
+        mexQuery(
+            {
+                input: {
+                    gid: groupJid.split('@')[0],
+                    participants: participants.map((jid) => ({ jid }))
+                }
+            },
+            INTEROP_MEX_QUERY_IDS.ADD_PARTICIPANTS,
+            'xwa2_interop_add_participants_to_group'
+        )
+
+    const queryInteropGroupInfo = async (groupJid) =>
+        mexQuery(
+            { group_input: { gid: groupJid.split('@')[0] } },
+            INTEROP_MEX_QUERY_IDS.QUERY_GROUP_INFO,
+            'xwa2_interop_group_query_by_id'
+        )
+
+    const updateInteropPrivacySetting = async (feature, setting) =>
+        mexQuery(
+            { feature, setting },
+            INTEROP_MEX_QUERY_IDS.PRIVACY_SETTINGS_UPDATE,
+            'xwa2_interop_privacy_setting_update'
+        )
+
+    return {
+        ...sock,
+        fetchIntegrators,
+        acceptInteropTOS,
+        optInIntegrators,
+        optOutIntegrators,
+        resolveInteropUser,
+        resolveInteropUsers,
+        blockInteropUser,
+        unblockInteropUser,
+        initInterop,
+        createInteropGroup,
+        leaveInteropGroup,
+        addParticipantsToInteropGroup,
+        queryInteropGroupInfo,
+        updateInteropPrivacySetting,
+        INTEGRATOR_BIRDYCHAT,
+        INTEGRATOR_HAIKET,
+        INTEROP_MEX_QUERY_IDS
+    }
+}
+
+module.exports = {
+    makeInteropSocket,
+    INTEGRATOR_BIRDYCHAT,
+    INTEGRATOR_HAIKET,
+    INTEROP_MEX_QUERY_IDS
+}