@sixcore/baileys 1.0.0 → 1.0.2

package/src/Utils/generics.ts

@@ -1,470 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { createHash, randomBytes } from 'crypto'
-import { proto } from '../../WAProto/index.js'
-const baileysVersion = [2, 3000, 1027934701]
-import type {
-	BaileysEventEmitter,
-	BaileysEventMap,
-	ConnectionState,
-	WACallUpdateType,
-	WAMessageKey,
-	WAVersion
-} from '../Types'
-import { DisconnectReason } from '../Types'
-import { type BinaryNode, getAllBinaryNodeChildren, jidDecode } from '../WABinary'
-import { sha256 } from './crypto'
-
-export const BufferJSON = {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	replacer: (k: any, value: any) => {
-		if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
-			return { type: 'Buffer', data: Buffer.from(value?.data || value).toString('base64') }
-		}
-
-		return value
-	},
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	reviver: (_: any, value: any) => {
-		if (typeof value === 'object' && value !== null && value.type === 'Buffer' && typeof value.data === 'string') {
-			return Buffer.from(value.data, 'base64')
-		}
-
-		if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-			const keys = Object.keys(value)
-			if (keys.length > 0 && keys.every(k => !isNaN(parseInt(k, 10)))) {
-				const values = Object.values(value)
-				if (values.every(v => typeof v === 'number')) {
-					return Buffer.from(values)
-				}
-			}
-		}
-
-		return value
-	}
-}
-
-export const getKeyAuthor = (key: WAMessageKey | undefined | null, meId = 'me') =>
-	(key?.fromMe ? meId : key?.participantAlt || key?.remoteJidAlt || key?.participant || key?.remoteJid) || ''
-
-export const writeRandomPadMax16 = (msg: Uint8Array) => {
-	const pad = randomBytes(1)
-	const padLength = (pad[0]! & 0x0f) + 1
-
-	return Buffer.concat([msg, Buffer.alloc(padLength, padLength)])
-}
-
-export const unpadRandomMax16 = (e: Uint8Array | Buffer) => {
-	const t = new Uint8Array(e)
-	if (0 === t.length) {
-		throw new Error('unpadPkcs7 given empty bytes')
-	}
-
-	var r = t[t.length - 1]!
-	if (r > t.length) {
-		throw new Error(`unpad given ${t.length} bytes, but pad is ${r}`)
-	}
-
-	return new Uint8Array(t.buffer, t.byteOffset, t.length - r)
-}
-
-// code is inspired by whatsmeow
-export const generateParticipantHashV2 = (participants: string[]): string => {
-	participants.sort()
-	const sha256Hash = sha256(Buffer.from(participants.join(''))).toString('base64')
-	return '2:' + sha256Hash.slice(0, 6)
-}
-
-export const encodeWAMessage = (message: proto.IMessage) => writeRandomPadMax16(proto.Message.encode(message).finish())
-
-export const generateRegistrationId = (): number => {
-	return Uint16Array.from(randomBytes(2))[0]! & 16383
-}
-
-export const encodeBigEndian = (e: number, t = 4) => {
-	let r = e
-	const a = new Uint8Array(t)
-	for (let i = t - 1; i >= 0; i--) {
-		a[i] = 255 & r
-		r >>>= 8
-	}
-
-	return a
-}
-
-export const toNumber = (t: Long | number | null | undefined): number =>
-	typeof t === 'object' && t ? ('toNumber' in t ? t.toNumber() : (t as Long).low) : t || 0
-
-/** unix timestamp of a date in seconds */
-export const unixTimestampSeconds = (date: Date = new Date()) => Math.floor(date.getTime() / 1000)
-
-export type DebouncedTimeout = ReturnType<typeof debouncedTimeout>
-
-export const debouncedTimeout = (intervalMs = 1000, task?: () => void) => {
-	let timeout: NodeJS.Timeout | undefined
-	return {
-		start: (newIntervalMs?: number, newTask?: () => void) => {
-			task = newTask || task
-			intervalMs = newIntervalMs || intervalMs
-			timeout && clearTimeout(timeout)
-			timeout = setTimeout(() => task?.(), intervalMs)
-		},
-		cancel: () => {
-			timeout && clearTimeout(timeout)
-			timeout = undefined
-		},
-		setTask: (newTask: () => void) => (task = newTask),
-		setInterval: (newInterval: number) => (intervalMs = newInterval)
-	}
-}
-
-export const delay = (ms: number) => delayCancellable(ms).delay
-
-export const delayCancellable = (ms: number) => {
-	const stack = new Error().stack
-	let timeout: NodeJS.Timeout
-	let reject: (error: any) => void
-	const delay: Promise<void> = new Promise((resolve, _reject) => {
-		timeout = setTimeout(resolve, ms)
-		reject = _reject
-	})
-	const cancel = () => {
-		clearTimeout(timeout)
-		reject(
-			new Boom('Cancelled', {
-				statusCode: 500,
-				data: {
-					stack
-				}
-			})
-		)
-	}
-
-	return { delay, cancel }
-}
-
-export async function promiseTimeout<T>(
-	ms: number | undefined,
-	promise: (resolve: (v: T) => void, reject: (error: any) => void) => void
-) {
-	if (!ms) {
-		return new Promise(promise)
-	}
-
-	const stack = new Error().stack
-	// Create a promise that rejects in <ms> milliseconds
-	const { delay, cancel } = delayCancellable(ms)
-	const p = new Promise((resolve, reject) => {
-		delay
-			.then(() =>
-				reject(
-					new Boom('Timed Out', {
-						statusCode: DisconnectReason.timedOut,
-						data: {
-							stack
-						}
-					})
-				)
-			)
-			.catch(err => reject(err))
-
-		promise(resolve, reject)
-	}).finally(cancel)
-	return p as Promise<T>
-}
-
-// inspired from whatsmeow code
-// https://github.com/tulir/whatsmeow/blob/64bc969fbe78d31ae0dd443b8d4c80a5d026d07a/send.go#L42
-export const generateMessageIDV2 = (userId?: string): string => {
-	const data = Buffer.alloc(8 + 20 + 16)
-	data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)))
-
-	if (userId) {
-		const id = jidDecode(userId)
-		if (id?.user) {
-			data.write(id.user, 8)
-			data.write('@c.us', 8 + id.user.length)
-		}
-	}
-
-	const random = randomBytes(16)
-	random.copy(data, 28)
-
-	const hash = createHash('sha256').update(data).digest()
-	return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18)
-}
-
-// generate a random ID to attach to a message
-export const generateMessageID = () => '3EB0' + randomBytes(18).toString('hex').toUpperCase()
-
-export function bindWaitForEvent<T extends keyof BaileysEventMap>(ev: BaileysEventEmitter, event: T) {
-	return async (check: (u: BaileysEventMap[T]) => Promise<boolean | undefined>, timeoutMs?: number) => {
-		let listener: (item: BaileysEventMap[T]) => void
-		let closeListener: (state: Partial<ConnectionState>) => void
-		await promiseTimeout<void>(timeoutMs, (resolve, reject) => {
-			closeListener = ({ connection, lastDisconnect }) => {
-				if (connection === 'close') {
-					reject(
-						lastDisconnect?.error || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })
-					)
-				}
-			}
-
-			ev.on('connection.update', closeListener)
-			listener = async update => {
-				if (await check(update)) {
-					resolve()
-				}
-			}
-
-			ev.on(event, listener)
-		}).finally(() => {
-			ev.off(event, listener)
-			ev.off('connection.update', closeListener)
-		})
-	}
-}
-
-export const bindWaitForConnectionUpdate = (ev: BaileysEventEmitter) => bindWaitForEvent(ev, 'connection.update')
-
-/**
- * utility that fetches latest baileys version from the master branch.
- * Use to ensure your WA connection is always on the latest version
- */
-export const fetchLatestBaileysVersion = async (options: RequestInit = {}) => {
-	const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts'
-	try {
-		const response = await fetch(URL, {
-			dispatcher: options.dispatcher,
-			method: 'GET',
-			headers: options.headers
-		})
-		if (!response.ok) {
-			throw new Boom(`Failed to fetch latest Baileys version: ${response.statusText}`, { statusCode: response.status })
-		}
-
-		const text = await response.text()
-		// Extract version from line 7 (const version = [...])
-		const lines = text.split('\n')
-		const versionLine = lines[6] // Line 7 (0-indexed)
-		const versionMatch = versionLine!.match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/)
-
-		if (versionMatch) {
-			const version = [parseInt(versionMatch[1]!), parseInt(versionMatch[2]!), parseInt(versionMatch[3]!)] as WAVersion
-
-			return {
-				version,
-				isLatest: true
-			}
-		} else {
-			throw new Error('Could not parse version from Defaults/index.ts')
-		}
-	} catch (error) {
-		return {
-			version: baileysVersion as WAVersion,
-			isLatest: false,
-			error
-		}
-	}
-}
-
-/**
- * A utility that fetches the latest web version of whatsapp.
- * Use to ensure your WA connection is always on the latest version
- */
-export const fetchLatestWaWebVersion = async (options: RequestInit = {}) => {
-	try {
-		// Absolute minimal headers required to bypass anti-bot detection
-		const defaultHeaders = {
-			'sec-fetch-site': 'none',
-			'user-agent':
-				'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
-		}
-
-		const headers = { ...defaultHeaders, ...options.headers }
-
-		const response = await fetch('https://web.whatsapp.com/sw.js', {
-			...options,
-			method: 'GET',
-			headers
-		})
-
-		if (!response.ok) {
-			throw new Boom(`Failed to fetch sw.js: ${response.statusText}`, { statusCode: response.status })
-		}
-
-		const data = await response.text()
-
-		const regex = /\\?"client_revision\\?":\s*(\d+)/
-		const match = data.match(regex)
-
-		if (!match?.[1]) {
-			return {
-				version: baileysVersion as WAVersion,
-				isLatest: false,
-				error: {
-					message: 'Could not find client revision in the fetched content'
-				}
-			}
-		}
-
-		const clientRevision = match[1]
-
-		return {
-			version: [2, 3000, +clientRevision] as WAVersion,
-			isLatest: true
-		}
-	} catch (error) {
-		return {
-			version: baileysVersion as WAVersion,
-			isLatest: false,
-			error
-		}
-	}
-}
-
-/** unique message tag prefix for MD clients */
-export const generateMdTagPrefix = () => {
-	const bytes = randomBytes(4)
-	return `${bytes.readUInt16BE()}.${bytes.readUInt16BE(2)}-`
-}
-
-const STATUS_MAP: { [_: string]: proto.WebMessageInfo.Status } = {
-	sender: proto.WebMessageInfo.Status.SERVER_ACK,
-	played: proto.WebMessageInfo.Status.PLAYED,
-	read: proto.WebMessageInfo.Status.READ,
-	'read-self': proto.WebMessageInfo.Status.READ
-}
-/**
- * Given a type of receipt, returns what the new status of the message should be
- * @param type type from receipt
- */
-export const getStatusFromReceiptType = (type: string | undefined) => {
-	const status = STATUS_MAP[type!]
-	if (typeof type === 'undefined') {
-		return proto.WebMessageInfo.Status.DELIVERY_ACK
-	}
-
-	return status
-}
-
-const CODE_MAP: { [_: string]: DisconnectReason } = {
-	conflict: DisconnectReason.connectionReplaced
-}
-
-/**
- * Stream errors generally provide a reason, map that to a baileys DisconnectReason
- * @param reason the string reason given, eg. "conflict"
- */
-export const getErrorCodeFromStreamError = (node: BinaryNode) => {
-	const [reasonNode] = getAllBinaryNodeChildren(node)
-	let reason = reasonNode?.tag || 'unknown'
-	const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession)
-
-	if (statusCode === DisconnectReason.restartRequired) {
-		reason = 'restart required'
-	}
-
-	return {
-		reason,
-		statusCode
-	}
-}
-
-export const getCallStatusFromNode = ({ tag, attrs }: BinaryNode) => {
-	let status: WACallUpdateType
-	switch (tag) {
-		case 'offer':
-		case 'offer_notice':
-			status = 'offer'
-			break
-		case 'terminate':
-			if (attrs.reason === 'timeout') {
-				status = 'timeout'
-			} else {
-				//fired when accepted/rejected/timeout/caller hangs up
-				status = 'terminate'
-			}
-
-			break
-		case 'reject':
-			status = 'reject'
-			break
-		case 'accept':
-			status = 'accept'
-			break
-		default:
-			status = 'ringing'
-			break
-	}
-
-	return status
-}
-
-const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: '
-
-export const getCodeFromWSError = (error: Error) => {
-	let statusCode = 500
-	if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
-		const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length)
-		if (!Number.isNaN(code) && code >= 400) {
-			statusCode = code
-		}
-	} else if (
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		(error as any)?.code?.startsWith('E') ||
-		error?.message?.includes('timed out')
-	) {
-		// handle ETIMEOUT, ENOTFOUND etc
-		statusCode = 408
-	}
-
-	return statusCode
-}
-
-/**
- * Is the given platform WA business
- * @param platform AuthenticationCreds.platform
- */
-export const isWABusinessPlatform = (platform: string) => {
-	return platform === 'smbi' || platform === 'smba'
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function trimUndefined(obj: { [_: string]: any }) {
-	for (const key in obj) {
-		if (typeof obj[key] === 'undefined') {
-			delete obj[key]
-		}
-	}
-
-	return obj
-}
-
-const CROCKFORD_CHARACTERS = '123456789ABCDEFGHJKLMNPQRSTVWXYZ'
-
-export function bytesToCrockford(buffer: Buffer): string {
-	let value = 0
-	let bitCount = 0
-	const crockford: string[] = []
-
-	for (const element of buffer) {
-		value = (value << 8) | (element & 0xff)
-		bitCount += 8
-
-		while (bitCount >= 5) {
-			crockford.push(CROCKFORD_CHARACTERS.charAt((value >>> (bitCount - 5)) & 31))
-			bitCount -= 5
-		}
-	}
-
-	if (bitCount > 0) {
-		crockford.push(CROCKFORD_CHARACTERS.charAt((value << (5 - bitCount)) & 31))
-	}
-
-	return crockford.join('')
-}
-
-export function encodeNewsletterMessage(message: proto.IMessage): Uint8Array {
-	return proto.Message.encode(message).finish()
-}

package/src/Utils/history.ts

@@ -1,114 +0,0 @@
-import { promisify } from 'util'
-import { inflate } from 'zlib'
-import { proto } from '../../WAProto/index.js'
-import type { Chat, Contact, WAMessage } from '../Types'
-import { WAMessageStubType } from '../Types'
-import { toNumber } from './generics'
-import { normalizeMessageContent } from './messages'
-import { downloadContentFromMessage } from './messages-media'
-
-const inflatePromise = promisify(inflate)
-
-export const downloadHistory = async (msg: proto.Message.IHistorySyncNotification, options: RequestInit) => {
-	const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options })
-	const bufferArray: Buffer[] = []
-	for await (const chunk of stream) {
-		bufferArray.push(chunk)
-	}
-
-	let buffer: Buffer = Buffer.concat(bufferArray)
-
-	// decompress buffer
-	buffer = await inflatePromise(buffer)
-
-	const syncData = proto.HistorySync.decode(buffer)
-	return syncData
-}
-
-export const processHistoryMessage = (item: proto.IHistorySync) => {
-	const messages: WAMessage[] = []
-	const contacts: Contact[] = []
-	const chats: Chat[] = []
-
-	switch (item.syncType) {
-		case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
-		case proto.HistorySync.HistorySyncType.RECENT:
-		case proto.HistorySync.HistorySyncType.FULL:
-		case proto.HistorySync.HistorySyncType.ON_DEMAND:
-			for (const chat of item.conversations! as Chat[]) {
-				contacts.push({
-					id: chat.id!,
-					name: chat.name || undefined,
-					lid: chat.lidJid || undefined,
-					phoneNumber: chat.pnJid || undefined
-				})
-
-				const msgs = chat.messages || []
-				delete chat.messages
-
-				for (const item of msgs) {
-					const message = item.message! as WAMessage
-					messages.push(message)
-
-					if (!chat.messages?.length) {
-						// keep only the most recent message in the chat array
-						chat.messages = [{ message }]
-					}
-
-					if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
-						chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp)
-					}
-
-					if (
-						(message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
-							message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
-						message.messageStubParameters?.[0]
-					) {
-						contacts.push({
-							id: message.key.participant || message.key.remoteJid!,
-							verifiedName: message.messageStubParameters?.[0]
-						})
-					}
-				}
-
-				chats.push({ ...chat })
-			}
-
-			break
-		case proto.HistorySync.HistorySyncType.PUSH_NAME:
-			for (const c of item.pushnames!) {
-				contacts.push({ id: c.id!, notify: c.pushname! })
-			}
-
-			break
-	}
-
-	return {
-		chats,
-		contacts,
-		messages,
-		syncType: item.syncType,
-		progress: item.progress
-	}
-}
-
-export const downloadAndProcessHistorySyncNotification = async (
-	msg: proto.Message.IHistorySyncNotification,
-	options: RequestInit
-) => {
-	let historyMsg: proto.HistorySync
-	if (msg.initialHistBootstrapInlinePayload) {
-		historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload))
-	} else {
-		historyMsg = await downloadHistory(msg, options)
-	}
-
-	return processHistoryMessage(historyMsg)
-}
-
-export const getHistoryMsg = (message: proto.IMessage) => {
-	const normalizedContent = !!message ? normalizeMessageContent(message) : undefined
-	const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification!
-
-	return anyHistoryMsg
-}

package/src/Utils/index.ts

@@ -1,18 +0,0 @@
-export * from './generics'
-export * from './decode-wa-message'
-export * from './messages'
-export * from './messages-media'
-export * from './validate-connection'
-export * from './crypto'
-export * from './signal'
-export * from './noise-handler'
-export * from './history'
-export * from './chat-utils'
-export * from './lt-hash'
-export * from './auth-utils'
-export * from './use-multi-file-auth-state'
-export * from './link-preview'
-export * from './event-buffer'
-export * from './process-message'
-export * from './message-retry-manager'
-export * from './browser-utils'

package/src/Utils/link-preview.ts

@@ -1,111 +0,0 @@
-import type { WAMediaUploadFunction, WAUrlInfo } from '../Types'
-import type { ILogger } from './logger'
-import { prepareWAMessageMedia } from './messages'
-import { extractImageThumb, getHttpStream } from './messages-media'
-
-const THUMBNAIL_WIDTH_PX = 192
-
-/** Fetches an image and generates a thumbnail for it */
-const getCompressedJpegThumbnail = async (url: string, { thumbnailWidth, fetchOpts }: URLGenerationOptions) => {
-	const stream = await getHttpStream(url, fetchOpts)
-	const result = await extractImageThumb(stream, thumbnailWidth)
-	return result
-}
-
-export type URLGenerationOptions = {
-	thumbnailWidth: number
-	fetchOpts: {
-		/** Timeout in ms */
-		timeout: number
-		proxyUrl?: string
-		headers?: HeadersInit
-	}
-	uploadImage?: WAMediaUploadFunction
-	logger?: ILogger
-}
-
-/**
- * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
- * Return undefined if the fetch failed or no URL was found
- * @param text first matched URL in text
- * @returns the URL info required to generate link preview
- */
-export const getUrlInfo = async (
-	text: string,
-	opts: URLGenerationOptions = {
-		thumbnailWidth: THUMBNAIL_WIDTH_PX,
-		fetchOpts: { timeout: 3000 }
-	}
-): Promise<WAUrlInfo | undefined> => {
-	try {
-		// retries
-		const retries = 0
-		const maxRetry = 5
-
-		const { getLinkPreview } = await import('link-preview-js')
-		let previewLink = text
-		if (!text.startsWith('https://') && !text.startsWith('http://')) {
-			previewLink = 'https://' + previewLink
-		}
-
-		const info = await getLinkPreview(previewLink, {
-			...opts.fetchOpts,
-			followRedirects: 'follow',
-			handleRedirects: (baseURL: string, forwardedURL: string) => {
-				const urlObj = new URL(baseURL)
-				const forwardedURLObj = new URL(forwardedURL)
-				if (retries >= maxRetry) {
-					return false
-				}
-
-				if (
-					forwardedURLObj.hostname === urlObj.hostname ||
-					forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
-					'www.' + forwardedURLObj.hostname === urlObj.hostname
-				) {
-					retries + 1
-					return true
-				} else {
-					return false
-				}
-			},
-			headers: opts.fetchOpts?.headers as {}
-		})
-		if (info && 'title' in info && info.title) {
-			const [image] = info.images
-
-			const urlInfo: WAUrlInfo = {
-				'canonical-url': info.url,
-				'matched-text': text,
-				title: info.title,
-				description: info.description,
-				originalThumbnailUrl: image
-			}
-
-			if (opts.uploadImage) {
-				const { imageMessage } = await prepareWAMessageMedia(
-					{ image: { url: image! } },
-					{
-						upload: opts.uploadImage,
-						mediaTypeOverride: 'thumbnail-link',
-						options: opts.fetchOpts
-					}
-				)
-				urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined
-				urlInfo.highQualityThumbnail = imageMessage || undefined
-			} else {
-				try {
-					urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined
-				} catch (error: any) {
-					opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail')
-				}
-			}
-
-			return urlInfo
-		}
-	} catch (error: any) {
-		if (!error.message.includes('receive a valid')) {
-			throw error
-		}
-	}
-}