@sixcore/baileys 1.0.0

package/src/Types/Socket.ts

@@ -0,0 +1,150 @@
+import type { Agent } from 'https'
+import type { URL } from 'url'
+import { proto } from '../../WAProto/index.js'
+import type { ILogger } from '../Utils/logger'
+import type { AuthenticationState, LIDMapping, SignalAuthState, TransactionCapabilityOptions } from './Auth'
+import type { GroupMetadata } from './GroupMetadata'
+import { type MediaConnInfo, type WAMessageKey } from './Message'
+import type { SignalRepositoryWithLIDStore } from './Signal'
+
+export type WAVersion = [number, number, number]
+export type WABrowserDescription = [string, string, string]
+
+export type CacheStore = {
+	/** get a cached key and change the stats */
+	get<T>(key: string): Promise<T> | T | undefined
+	/** set a key in the cache */
+	set<T>(key: string, value: T): Promise<void> | void | number | boolean
+	/** delete a key from the cache */
+	del(key: string): void | Promise<void> | number | boolean
+	/** flush all data */
+	flushAll(): void | Promise<void>
+}
+
+export type PossiblyExtendedCacheStore = CacheStore & {
+	mget?: <T>(keys: string[]) => Promise<Record<string, T | undefined>>
+	mset?: <T>(entries: { key: string; value: T }[]) => Promise<void> | void | number | boolean
+	mdel?: (keys: string[]) => void | Promise<void> | number | boolean
+}
+
+export type PatchedMessageWithRecipientJID = proto.IMessage & { recipientJid?: string }
+
+export type SocketConfig = {
+	/** the WS url to connect to WA */
+	waWebSocketUrl: string | URL
+	/** Fails the connection if the socket times out in this interval */
+	connectTimeoutMs: number
+	/** Default timeout for queries, undefined for no timeout */
+	defaultQueryTimeoutMs: number | undefined
+	/** ping-pong interval for WS connection */
+	keepAliveIntervalMs: number
+	/** should baileys use the mobile api instead of the multi device api
+	 * @deprecated This feature has been removed
+	 */
+	mobile?: boolean
+	/** proxy agent */
+	agent?: Agent
+	/** logger */
+	logger: ILogger
+	/** version to connect with */
+	version: WAVersion
+	/** override browser config */
+	browser: WABrowserDescription
+	/** agent used for fetch requests -- uploading/downloading media */
+	fetchAgent?: Agent
+	/** should the QR be printed in the terminal
+	 * @deprecated This feature has been removed
+	 */
+	printQRInTerminal?: boolean
+	/** should events be emitted for actions done by this socket connection */
+	emitOwnEvents: boolean
+	/** custom upload hosts to upload media to */
+	customUploadHosts: MediaConnInfo['hosts']
+	/** time to wait between sending new retry requests */
+	retryRequestDelayMs: number
+	/** max retry count */
+	maxMsgRetryCount: number
+	/** time to wait for the generation of the next QR in ms */
+	qrTimeout?: number
+	/** provide an auth state object to maintain the auth state */
+	auth: AuthenticationState
+	/** manage history processing with this control; by default will sync up everything */
+	shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean
+	/** transaction capability options for SignalKeyStore */
+	transactionOpts: TransactionCapabilityOptions
+	/** marks the client as online whenever the socket successfully connects */
+	markOnlineOnConnect: boolean
+	/** alphanumeric country code (USA -> US) for the number used */
+	countryCode: string
+	/** provide a cache to store media, so does not have to be re-uploaded */
+	mediaCache?: CacheStore
+	/**
+	 * map to store the retry counts for failed messages;
+	 * used to determine whether to retry a message or not */
+	msgRetryCounterCache?: CacheStore
+	/** provide a cache to store a user's device list */
+	userDevicesCache?: PossiblyExtendedCacheStore
+	/** cache to store call offers */
+	callOfferCache?: CacheStore
+	/** cache to track placeholder resends */
+	placeholderResendCache?: CacheStore
+	/** width for link preview images */
+	linkPreviewImageThumbnailWidth: number
+	/** Should Baileys ask the phone for full history, will be received async */
+	syncFullHistory: boolean
+	/** Should baileys fire init queries automatically, default true */
+	fireInitQueries: boolean
+	/**
+	 * generate a high quality link preview,
+	 * entails uploading the jpegThumbnail to WA
+	 * */
+	generateHighQualityLinkPreview: boolean
+
+	/** Enable automatic session recreation for failed messages */
+	enableAutoSessionRecreation: boolean
+
+	/** Enable recent message caching for retry handling */
+	enableRecentMessageCache: boolean
+
+	/**
+	 * Returns if a jid should be ignored,
+	 * no event for that jid will be triggered.
+	 * Messages from that jid will also not be decrypted
+	 * */
+	shouldIgnoreJid: (jid: string) => boolean | undefined
+
+	/**
+	 * Optionally patch the message before sending out
+	 * */
+	patchMessageBeforeSending: (
+		msg: proto.IMessage,
+		recipientJids?: string[]
+	) =>
+		| Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID>
+		| PatchedMessageWithRecipientJID[]
+		| PatchedMessageWithRecipientJID
+
+	/** verify app state MACs */
+	appStateMacVerification: {
+		patch: boolean
+		snapshot: boolean
+	}
+
+	/** options for HTTP fetch requests */
+	options: RequestInit
+	/**
+	 * fetch a message from your store
+	 * implement this so that messages failed to send
+	 * (solves the "this message can take a while" issue) can be retried
+	 * */
+	getMessage: (key: WAMessageKey) => Promise<proto.IMessage | undefined>
+
+	/** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+	cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>
+
+	makeSignalRepository: (
+		auth: SignalAuthState,
+		logger: ILogger,
+		pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>
+	) => SignalRepositoryWithLIDStore
+}

package/src/Types/State.ts

@@ -0,0 +1,43 @@
+import { Boom } from '@hapi/boom'
+import type { Contact } from './Contact'
+
+export enum SyncState {
+	/** The socket is connecting, but we haven't received pending notifications yet. */
+	Connecting,
+	/** Pending notifications received. Buffering events until we decide whether to sync or not. */
+	AwaitingInitialSync,
+	/** The initial app state sync (history, etc.) is in progress. Buffering continues. */
+	Syncing,
+	/** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
+	Online
+}
+
+export type WAConnectionState = 'open' | 'connecting' | 'close'
+
+export type ConnectionState = {
+	/** connection is now open, connecting or closed */
+	connection: WAConnectionState
+
+	/** the error that caused the connection to close */
+	lastDisconnect?: {
+		// TODO: refactor and gain independence from Boom
+		error: Boom | Error | undefined
+		date: Date
+	}
+	/** is this a new login */
+	isNewLogin?: boolean
+	/** the current QR code */
+	qr?: string
+	/** has the device received all pending notifications while it was offline */
+	receivedPendingNotifications?: boolean
+	/** legacy connection options */
+	legacy?: {
+		phoneConnected: boolean
+		user?: Contact
+	}
+	/**
+	 * if the client is shown as an active, online client.
+	 * If this is false, the primary phone and other devices will receive notifs
+	 * */
+	isOnline?: boolean
+}

package/src/Types/USync.ts

@@ -0,0 +1,27 @@
+import type { BinaryNode } from '../WABinary'
+import { USyncUser } from '../WAUSync'
+
+/**
+ * Defines the interface for a USyncQuery protocol
+ */
+export interface USyncQueryProtocol {
+	/**
+	 * The name of the protocol
+	 */
+	name: string
+	/**
+	 * Defines what goes inside the query part of a USyncQuery
+	 */
+	getQueryElement: () => BinaryNode
+	/**
+	 * Defines what goes inside the user part of a USyncQuery
+	 */
+	getUserElement: (user: USyncUser) => BinaryNode | null
+
+	/**
+	 * Parse the result of the query
+	 * @param data Data from the result
+	 * @returns Whatever the protocol is supposed to return
+	 */
+	parser: (data: BinaryNode) => unknown
+}

package/src/Types/globals.d.ts

@@ -0,0 +1,8 @@
+declare global {
+	interface RequestInit {
+		dispatcher?: any
+		duplex?: 'half' | 'full'
+	}
+}
+
+export {}

package/src/Types/index.ts

@@ -0,0 +1,67 @@
+export * from './Auth'
+export * from './GroupMetadata'
+export * from './Chat'
+export * from './Contact'
+export * from './State'
+export * from './Message'
+export * from './Socket'
+export * from './Events'
+export * from './Product'
+export * from './Call'
+export * from './Signal'
+export * from './Newsletter'
+
+import type { AuthenticationState } from './Auth'
+import type { SocketConfig } from './Socket'
+
+export type UserFacingSocketConfig = Partial<SocketConfig> & { auth: AuthenticationState }
+
+export type BrowsersMap = {
+	ubuntu(browser: string): [string, string, string]
+	macOS(browser: string): [string, string, string]
+	baileys(browser: string): [string, string, string]
+	windows(browser: string): [string, string, string]
+	appropriate(browser: string): [string, string, string]
+}
+
+export enum DisconnectReason {
+	connectionClosed = 428,
+	connectionLost = 408,
+	connectionReplaced = 440,
+	timedOut = 408,
+	loggedOut = 401,
+	badSession = 500,
+	restartRequired = 515,
+	multideviceMismatch = 411,
+	forbidden = 403,
+	unavailableService = 503
+}
+
+export type WAInitResponse = {
+	ref: string
+	ttl: number
+	status: 200
+}
+
+export type WABusinessHoursConfig = {
+	day_of_week: string
+	mode: string
+	open_time?: number
+	close_time?: number
+}
+
+export type WABusinessProfile = {
+	description: string
+	email: string | undefined
+	business_hours: {
+		timezone?: string
+		config?: WABusinessHoursConfig[]
+		business_config?: WABusinessHoursConfig[]
+	}
+	website: string[]
+	category?: string
+	wid?: string
+	address?: string
+}
+
+export type CurveKeyPair = { private: Uint8Array; public: Uint8Array }

package/src/Utils/auth-utils.ts

@@ -0,0 +1,331 @@
+import NodeCache from '@cacheable/node-cache'
+import { AsyncLocalStorage } from 'async_hooks'
+import { Mutex } from 'async-mutex'
+import { randomBytes } from 'crypto'
+import PQueue from 'p-queue'
+import { DEFAULT_CACHE_TTLS } from '../Defaults'
+import type {
+	AuthenticationCreds,
+	CacheStore,
+	SignalDataSet,
+	SignalDataTypeMap,
+	SignalKeyStore,
+	SignalKeyStoreWithTransaction,
+	TransactionCapabilityOptions
+} from '../Types'
+import { Curve, signedKeyPair } from './crypto'
+import { delay, generateRegistrationId } from './generics'
+import type { ILogger } from './logger'
+import { PreKeyManager } from './pre-key-manager'
+
+/**
+ * Transaction context stored in AsyncLocalStorage
+ */
+interface TransactionContext {
+	cache: SignalDataSet
+	mutations: SignalDataSet
+	dbQueries: number
+}
+
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(
+	store: SignalKeyStore,
+	logger?: ILogger,
+	_cache?: CacheStore
+): SignalKeyStore {
+	const cache =
+		_cache ||
+		new NodeCache<SignalDataTypeMap[keyof SignalDataTypeMap]>({
+			stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+			useClones: false,
+			deleteOnExpire: true
+		})
+
+	// Mutex for protecting cache operations
+	const cacheMutex = new Mutex()
+
+	function getUniqueId(type: string, id: string) {
+		return `${type}.${id}`
+	}
+
+	return {
+		async get(type, ids) {
+			return cacheMutex.runExclusive(async () => {
+				const data: { [_: string]: SignalDataTypeMap[typeof type] } = {}
+				const idsToFetch: string[] = []
+
+				for (const id of ids) {
+					const item = (await cache.get<SignalDataTypeMap[typeof type]>(getUniqueId(type, id))) as any
+					if (typeof item !== 'undefined') {
+						data[id] = item
+					} else {
+						idsToFetch.push(id)
+					}
+				}
+
+				if (idsToFetch.length) {
+					logger?.trace({ items: idsToFetch.length }, 'loading from store')
+					const fetched = await store.get(type, idsToFetch)
+					for (const id of idsToFetch) {
+						const item = fetched[id]
+						if (item) {
+							data[id] = item
+							await cache.set(getUniqueId(type, id), item as SignalDataTypeMap[keyof SignalDataTypeMap])
+						}
+					}
+				}
+
+				return data
+			})
+		},
+		async set(data) {
+			return cacheMutex.runExclusive(async () => {
+				let keys = 0
+				for (const type in data) {
+					for (const id in data[type as keyof SignalDataTypeMap]) {
+						await cache.set(getUniqueId(type, id), data[type as keyof SignalDataTypeMap]![id]!)
+						keys += 1
+					}
+				}
+
+				logger?.trace({ keys }, 'updated cache')
+				await store.set(data)
+			})
+		},
+		async clear() {
+			await cache.flushAll()
+			await store.clear?.()
+		}
+	}
+}
+
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export const addTransactionCapability = (
+	state: SignalKeyStore,
+	logger: ILogger,
+	{ maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions
+): SignalKeyStoreWithTransaction => {
+	const txStorage = new AsyncLocalStorage<TransactionContext>()
+
+	// Queues for concurrency control
+	const keyQueues = new Map<string, PQueue>()
+	const txMutexes = new Map<string, Mutex>()
+
+	// Pre-key manager for specialized operations
+	const preKeyManager = new PreKeyManager(state, logger)
+
+	/**
+	 * Get or create a queue for a specific key type
+	 */
+	function getQueue(key: string): PQueue {
+		if (!keyQueues.has(key)) {
+			keyQueues.set(key, new PQueue({ concurrency: 1 }))
+		}
+
+		return keyQueues.get(key)!
+	}
+
+	/**
+	 * Get or create a transaction mutex
+	 */
+	function getTxMutex(key: string): Mutex {
+		if (!txMutexes.has(key)) {
+			txMutexes.set(key, new Mutex())
+		}
+
+		return txMutexes.get(key)!
+	}
+
+	/**
+	 * Check if currently in a transaction
+	 */
+	function isInTransaction(): boolean {
+		return !!txStorage.getStore()
+	}
+
+	/**
+	 * Commit transaction with retries
+	 */
+	async function commitWithRetry(mutations: SignalDataSet): Promise<void> {
+		if (Object.keys(mutations).length === 0) {
+			logger.trace('no mutations in transaction')
+			return
+		}
+
+		logger.trace('committing transaction')
+
+		for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+			try {
+				await state.set(mutations)
+				logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction')
+				return
+			} catch (error) {
+				const retriesLeft = maxCommitRetries - attempt - 1
+				logger.warn(`failed to commit mutations, retries left=${retriesLeft}`)
+
+				if (retriesLeft === 0) {
+					throw error
+				}
+
+				await delay(delayBetweenTriesMs)
+			}
+		}
+	}
+
+	return {
+		get: async (type, ids) => {
+			const ctx = txStorage.getStore()
+
+			if (!ctx) {
+				// No transaction - direct read without exclusive lock for concurrency
+				return state.get(type, ids)
+			}
+
+			// In transaction - check cache first
+			const cached = ctx.cache[type] || {}
+			const missing = ids.filter(id => !(id in cached))
+
+			if (missing.length > 0) {
+				ctx.dbQueries++
+				logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction')
+
+				const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing))
+
+				// Update cache
+				ctx.cache[type] = ctx.cache[type] || ({} as any)
+				Object.assign(ctx.cache[type]!, fetched)
+			}
+
+			// Return requested ids from cache
+			const result: { [key: string]: any } = {}
+			for (const id of ids) {
+				const value = ctx.cache[type]?.[id]
+				if (value !== undefined && value !== null) {
+					result[id] = value
+				}
+			}
+
+			return result
+		},
+
+		set: async data => {
+			const ctx = txStorage.getStore()
+
+			if (!ctx) {
+				// No transaction - direct write with queue protection
+				const types = Object.keys(data)
+
+				// Process pre-keys with validation
+				for (const type_ of types) {
+					const type = type_ as keyof SignalDataTypeMap
+					if (type === 'pre-key') {
+						await preKeyManager.validateDeletions(data, type)
+					}
+				}
+
+				// Write all data in parallel
+				await Promise.all(
+					types.map(type =>
+						getQueue(type).add(async () => {
+							const typeData = { [type]: data[type as keyof SignalDataTypeMap] } as SignalDataSet
+							await state.set(typeData)
+						})
+					)
+				)
+				return
+			}
+
+			// In transaction - update cache and mutations
+			logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+
+			for (const key_ in data) {
+				const key = key_ as keyof SignalDataTypeMap
+
+				// Ensure structures exist
+				ctx.cache[key] = ctx.cache[key] || ({} as any)
+				ctx.mutations[key] = ctx.mutations[key] || ({} as any)
+
+				// Special handling for pre-keys
+				if (key === 'pre-key') {
+					await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true)
+				} else {
+					// Normal key types
+					Object.assign(ctx.cache[key]!, data[key])
+					Object.assign(ctx.mutations[key]!, data[key])
+				}
+			}
+		},
+
+		isInTransaction,
+
+		transaction: async (work, key) => {
+			const existing = txStorage.getStore()
+
+			// Nested transaction - reuse existing context
+			if (existing) {
+				logger.trace('reusing existing transaction context')
+				return work()
+			}
+
+			// New transaction - acquire mutex and create context
+			return getTxMutex(key).runExclusive(async () => {
+				const ctx: TransactionContext = {
+					cache: {},
+					mutations: {},
+					dbQueries: 0
+				}
+
+				logger.trace('entering transaction')
+
+				try {
+					const result = await txStorage.run(ctx, work)
+
+					// Commit mutations
+					await commitWithRetry(ctx.mutations)
+
+					logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed')
+
+					return result
+				} catch (error) {
+					logger.error({ error }, 'transaction failed, rolling back')
+					throw error
+				}
+			})
+		}
+	}
+}
+
+export const initAuthCreds = (): AuthenticationCreds => {
+	const identityKey = Curve.generateKeyPair()
+	return {
+		noiseKey: Curve.generateKeyPair(),
+		pairingEphemeralKeyPair: Curve.generateKeyPair(),
+		signedIdentityKey: identityKey,
+		signedPreKey: signedKeyPair(identityKey, 1),
+		registrationId: generateRegistrationId(),
+		advSecretKey: randomBytes(32).toString('base64'),
+		processedHistoryMessages: [],
+		nextPreKeyId: 1,
+		firstUnuploadedPreKeyId: 1,
+		accountSyncCounter: 0,
+		accountSettings: {
+			unarchiveChats: false
+		},
+		registered: false,
+		pairingCode: undefined,
+		lastPropHash: undefined,
+		routingInfo: undefined,
+		additionalData: undefined
+	}
+}

package/src/Utils/browser-utils.ts

@@ -0,0 +1,31 @@
+import { platform, release } from 'os'
+import { proto } from '../../WAProto/index.js'
+import type { BrowsersMap } from '../Types'
+
+const PLATFORM_MAP = {
+	aix: 'AIX',
+	darwin: 'Mac OS',
+	win32: 'Windows',
+	android: 'Android',
+	freebsd: 'FreeBSD',
+	openbsd: 'OpenBSD',
+	sunos: 'Solaris',
+	linux: undefined,
+	haiku: undefined,
+	cygwin: undefined,
+	netbsd: undefined
+}
+
+export const Browsers: BrowsersMap = {
+	ubuntu: browser => ['Ubuntu', browser, '22.04.4'],
+	macOS: browser => ['Mac OS', browser, '14.4.1'],
+	baileys: browser => ['Baileys', browser, '6.5.0'],
+	windows: browser => ['Windows', browser, '10.0.22631'],
+	/** The appropriate browser based on your OS & release */
+	appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
+}
+
+export const getPlatformId = (browser: string) => {
+	const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase() as any]
+	return platformType ? platformType.toString() : '1' //chrome
+}