gifted-baileys 1.5.6 → 1.5.7

package/src/Utils/generics.ts

@@ -1,434 +0,0 @@
-import { Boom } from '@hapi/boom'
-import axios, { AxiosRequestConfig } from 'axios'
-import { randomBytes, createHash } from 'crypto'
-import { platform, release } from 'os'
-import { Logger } from 'pino'
-import { proto } from '../../WAProto'
-import { version as baileysVersion } from '../Defaults/baileys-version.json'
-import { BaileysEventEmitter, BaileysEventMap, DisconnectReason, WACallUpdateType, WAVersion } from '../Types'
-import { BinaryNode, getAllBinaryNodeChildren, jidDecode } from '../WABinary'
-
-const PLATFORM_MAP = {
-	'aix': 'AIX',
-	'darwin': 'Mac OS',
-	'win32': 'Windows',
-	'android': 'Android'
-}
-
-export const Browsers = {
-	ubuntu: browser => ['Ubuntu', browser, '20.0.04'] as [string, string, string],
-	macOS: browser => ['Mac OS', browser, '10.15.7'] as [string, string, string],
-	baileys: browser => ['Baileys', browser, '4.0.0'] as [string, string, string],
-	windows: browser => ['Windows', browser, '10.0.22621'] as [string, string, string],
-	/** The appropriate browser based on your OS & release */
-	appropriate: browser => [ PLATFORM_MAP[platform()] || 'Ubuntu', browser, release() ] as [string, string, string]
-}
-
-export const BufferJSON = {
-	replacer: (k, 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
-	},
-	reviver: (_, value: any) => {
-		if(typeof value === 'object' && !!value && (value.buffer === true || value.type === 'Buffer')) {
-			const val = value.data || value.value
-			return typeof val === 'string' ? Buffer.from(val, 'base64') : Buffer.from(val || [])
-		}
-
-		return value
-	}
-}
-
-export const getKeyAuthor = (
-	key: proto.IMessageKey | undefined | null,
-	meId: string = 'me'
-) => (
-	(key?.fromMe ? meId : key?.participant || key?.remoteJid) || ''
-)
-
-export const writeRandomPadMax16 = (msg: Uint8Array) => {
-	const pad = randomBytes(1)
-	pad[0] &= 0xf
-	if(!pad[0]) {
-		pad[0] = 0xf
-	}
-
-	return Buffer.concat([msg, Buffer.alloc(pad[0], pad[0])])
-}
-
-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)
-}
-
-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 any).low) : t)
-
-/** 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: number = 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) => 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) => 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>
-}
-
-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 'ASS' + hash.toString('hex').toUpperCase().substring(0, 18)
-}
-
-// generate a random ID to attach to a message
-export const generateMessageID = () => 'SSA' + randomBytes(6).toString('hex').toUpperCase()
-
-export function bindWaitForEvent<T extends keyof BaileysEventMap>(ev: BaileysEventEmitter, event: T) {
-	return async(check: (u: BaileysEventMap[T]) => boolean | undefined, timeoutMs?: number) => {
-		let listener: (item: BaileysEventMap[T]) => void
-		let closeListener: any
-		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 = (update) => {
-						if(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')
-
-export const printQRIfNecessaryListener = (ev: BaileysEventEmitter, logger: Logger) => {
-	ev.on('connection.update', async({ qr }) => {
-		if(qr) {
-			const QR = await import('qrcode-terminal')
-				.then(m => m.default || m)
-				.catch(() => {
-					logger.error('QR code terminal not added as dependency')
-				})
-			QR?.generate(qr, { small: true })
-		}
-	})
-}
-
-/**
- * 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: AxiosRequestConfig<any> = { }) => {
-	const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/baileys-version.json'
-	try {
-		const result = await axios.get<{ version: WAVersion }>(
-			URL,
-			{
-				...options,
-				responseType: 'json'
-			}
-		)
-		return {
-			version: result.data.version,
-			isLatest: true
-		}
-	} 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: AxiosRequestConfig<any>) => {
-	try {
-		const result = await axios.get(
-			'https://web.whatsapp.com/check-update?version=1&platform=web',
-			{
-				...options,
-				responseType: 'json'
-			}
-		)
-		const version = result.data.currentVersion.split('.')
-		return {
-			version: [+version[0], +version[1], +version[2]] 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 } = {
-	'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 {
-			status = 'reject'
-		}
-
-		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(
-		(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'
-}
-
-export function trimUndefined(obj: 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(let i = 0; i < buffer.length; i++) {
-		value = (value << 8) | (buffer[i] & 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('')
-}

package/src/Utils/history.ts

@@ -1,112 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import { promisify } from 'util'
-import { inflate } from 'zlib'
-import { proto } from '../../WAProto'
-import { Chat, Contact, WAMessageStubType } from '../Types'
-import { isJidUser } from '../WABinary'
-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: AxiosRequestConfig<any>
-) => {
-	const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options })
-	const bufferArray: Buffer[] = []
-	for await (const chunk of stream) {
-		bufferArray.push(chunk)
-	}
-
-	let 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: proto.IWebMessageInfo[] = []
-	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:
-		for(const chat of item.conversations! as Chat[]) {
-			contacts.push({ id: chat.id, name: chat.name || undefined })
-
-			const msgs = chat.messages || []
-			delete chat.messages
-			delete chat.archived
-			delete chat.muteEndTime
-			delete chat.pinned
-
-			for(const item of msgs) {
-				const message = item.message!
-				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],
-					})
-				}
-			}
-
-			if(isJidUser(chat.id) && chat.readOnly && chat.archived) {
-				delete chat.readOnly
-			}
-
-			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,
-	}
-}
-
-export const downloadAndProcessHistorySyncNotification = async(
-	msg: proto.Message.IHistorySyncNotification,
-	options: AxiosRequestConfig<any>
-) => {
-	const 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,17 +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 './baileys-event-stream'
-export * from './use-multi-file-auth-state'
-export * from './link-preview'
-export * from './event-buffer'
-export * from './process-message'

package/src/Utils/link-preview.ts

@@ -1,122 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import { Logger } from 'pino'
-import { WAMediaUploadFunction, WAUrlInfo } from '../Types'
-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?: AxiosRequestConfig<{}>['headers']
-	}
-	uploadImage?: WAMediaUploadFunction
-	logger?: Logger
-}
-
-/**
- * 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 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) {
-					opts.logger?.debug(
-						{ err: error.stack, url: previewLink },
-						'error in generating thumbnail'
-					)
-				}
-			}
-
-			return urlInfo
-		}
-	} catch(error) {
-		if(!error.message.includes('receive a valid')) {
-			throw error
-		}
-	}
-}

package/src/Utils/logger.ts

@@ -1,3 +0,0 @@
-import P from 'pino'
-
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` })