@sixcore/baileys 1.0.0 → 1.0.2

package/src/Types/Socket.ts

@@ -1,150 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

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

package/src/Types/index.ts

@@ -1,67 +0,0 @@
-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

@@ -1,331 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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
-}