@nexustechpro/baileys 2.1.3 → 2.1.6

package/lib/Socket/socket.js

@@ -36,9 +36,10 @@ import {
   makeNoiseHandler,
   promiseTimeout,
   signedKeyPair,
-  xmppSignedPreKey
+  xmppSignedPreKey,
+  getPlatformId,
+  isAndroidBrowser
 } from '../Utils/index.js'
-import { getPlatformId, migrateIndexKey } from '../Utils/index.js'
 import {
   assertNodeErrorFree,
   binaryNodeToString,
@@ -117,6 +118,12 @@ export const makeSocket = (config) => {
     })
   }
 
+  if (browser[1].toLocaleLowerCase().includes('android')) {
+    logger.warn(
+      '⚠️ Using the Android browser is experimental and may lead to unexpected behavior. Use at your own risk.'
+    )
+  }
+
   const ev = makeEventBuffer(logger)
   const { creds } = authState
   const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
@@ -629,8 +636,8 @@ export const makeSocket = (config) => {
         content: [
           { tag: 'link_code_pairing_wrapped_companion_ephemeral_pub', attrs: {}, content: await generatePairingKey() },
           { tag: 'companion_server_auth_key_pub', attrs: {}, content: authState.creds.noiseKey.public },
-          { tag: 'companion_platform_id', attrs: {}, content: getCompanionPlatformId(browser) },
-          { tag: 'companion_platform_display', attrs: {}, content: `${browser[1]} (${browser[0]})` },
+          { tag: 'companion_platform_id', attrs: {}, content: isAndroidBrowser(browser) ? getPlatformId('Chrome') : getCompanionPlatformId(browser) },
+          { tag: 'companion_platform_display', attrs: {}, content: isAndroidBrowser(browser) ? 'Chrome (Mac OS)' : `${browser[1]} (${browser[0]})` },
           { tag: 'link_code_pairing_nonce', attrs: {}, content: '0' }
         ]
       }]
@@ -747,7 +754,6 @@ export const makeSocket = (config) => {
     ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } })
     ev.emit('connection.update', { connection: 'open' })
     void sendUnifiedSession()
-
     if (node.attrs.lid && authState.creds.me?.id) {
       const myLID = node.attrs.lid
       process.nextTick(async () => {
@@ -755,23 +761,27 @@ export const makeSocket = (config) => {
           const myPN = authState.creds.me.id
           // Store own LID-PN mapping
           await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }])
-          // Build device-list using index-based batching to avoid unbounded key growth
+          // Write own device entry — one key per user, no index blob
           const { user, device } = jidDecode(myPN)
-          const currentBatch = await migrateIndexKey(authState.keys, 'device-list')
-          currentBatch[user] = [device?.toString() || '0']
-          const deviceKeys = Object.keys(currentBatch)
-          if (deviceKeys.length > BATCH_SIZE) {
-            deviceKeys.sort()
-            deviceKeys.slice(0, deviceKeys.length - BATCH_SIZE).forEach((k) => delete currentBatch[k])
-          }
-          await authState.keys.set({ 'device-list': { index: currentBatch } })
+          await authState.keys.set({ 'device-list': { [user]: [device?.toString() || '0'] } })
           // Migrate own session from PN → LID
           await signalRepository.migrateSession(myPN, myLID)
           logger.info({ myPN, myLID }, 'Own LID session created successfully')
-          // Batch-migrate any remaining PN sessions to LID
-          if (signalRepository.migrateAllPNSessionsToLID) {
+
+          // Migrate any other known PN sessions to LID (replaces removed migrateAllPNSessionsToLID)
+          if (signalRepository.lidMapping.getLIDPNMappings) {
             try {
-              const migrated = await signalRepository.migrateAllPNSessionsToLID()
+              const allMappings = await signalRepository.lidMapping.getLIDPNMappings()
+              const others = (allMappings || []).filter(m => m.pn !== myPN && m.lid && m.pn)
+              let migrated = 0
+              for (const { pn, lid } of others) {
+                try {
+                  await signalRepository.migrateSession(pn, lid)
+                  migrated++
+                } catch (sessErr) {
+                  logger.warn({ error: sessErr, pn, lid }, 'Failed to migrate individual PN session to LID')
+                }
+              }
               if (migrated > 0) logger.info({ migrated }, 'Batch-migrated PN sessions to LID on connect')
             } catch (migErr) {
               logger.warn({ error: migErr }, 'Failed to batch-migrate PN sessions to LID')
@@ -783,7 +793,6 @@ export const makeSocket = (config) => {
       })
     }
   })
-
   // ─── Stream / connection error handlers ─────────────────────────────────────
 
   ws.on('CB:stream:error', (node) => {

package/lib/Utils/browser-utils.js

@@ -18,11 +18,20 @@ export const Browsers = {
     macOS: browser => ['Mac OS', browser, '14.4.1'],
     baileys: browser => ['Baileys', browser, '6.5.0'],
     windows: browser => ['Windows', browser, '10.0.22631'],
+    android: browser => [browser, 'Android', ''],
     /** The appropriate browser based on your OS & release */
     appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
 };
 export const getPlatformId = (browser) => {
-    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
-    return platformType ? platformType.toString() : '1'; //chrome
-};
+    const upper = browser.toUpperCase()
+    if (upper === 'ANDROID') {
+        return proto.DeviceProps.PlatformType['ANDROID_PHONE'].toString()
+    }
+    const platformType = proto.DeviceProps.PlatformType[upper]
+    return platformType ? platformType.toString() : '1' // chrome
+}
+
+export const isAndroidBrowser = (browser) => {
+    return browser[1]?.toUpperCase() === 'ANDROID'
+}
 //# sourceMappingURL=browser-utils.js.map

package/lib/Utils/key-store.js

@@ -1,22 +1,3 @@
 // ─── Key Store Helpers ─────────────────────────────────────────────────────────
 // Single source of truth for blob key names — change here, changes everywhere
-export const SESSION_INDEX_KEY = 'index'
-export const DEVICE_LIST_INDEX_KEY = 'index'
-export const TC_TOKEN_INDEX_KEY = 'index'
-
-// Migrates old _index blob to new index key in-place, returns the batch data
-export const migrateIndexKey = async (keys, type) => {
-    const oldKeys = ['_index', '__index']
-    const newKey = 'index'
-
-    for (const oldKey of oldKeys) {
-        const oldData = await keys.get(type, [oldKey])
-        if (oldData?.[oldKey] !== null && oldData?.[oldKey] !== undefined && typeof oldData[oldKey] === 'object') {
-            await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
-            return oldData[oldKey]
-        }
-    }
-
-    const newData = await keys.get(type, [newKey])
-    return newData?.[newKey] || {}
-}
+export const TC_TOKEN_INDEX_KEY = '__index'

package/lib/Utils/messages-media.js

@@ -235,35 +235,40 @@ export async function getAudioWaveform(buffer, logger) {
 
 // ─── FFMPEG CONVERTERS ────────────────────────────────────────────────────────
 const convertToOpusBuffer = async (buffer, logger) => {
+    if (buffer[0] === 0x4F && buffer[1] === 0x67 && buffer[2] === 0x67 && buffer[3] === 0x53) return buffer
     const ffmpegPath = await getFfmpegPath()
     const inputPath = join(tmpdir(), 'opus-in-' + generateMessageIDV2())
+    const outputPath = join(tmpdir(), 'opus-out-' + generateMessageIDV2() + '.ogg')
     await fs.writeFile(inputPath, buffer)
     try {
-        return await new Promise((resolve, reject) => {
-            const ff = spawn(ffmpegPath, ['-y', '-i', inputPath, '-c:a', 'libopus', '-b:a', '64k', '-vbr', 'on', '-compression_level', '10', '-frame_duration', '20', '-application', 'voip', '-f', 'ogg', 'pipe:1'], { stdio: ['ignore', 'pipe', 'pipe'] })
-            const chunks = []
-            ff.stdout.on('data', chunk => chunks.push(chunk))
-            ff.stderr.on('data', () => { })
-            ff.on('close', code => code === 0 ? resolve(Buffer.concat(chunks)) : reject(new Error(`FFmpeg Opus exited with code ${code}`)))
+        await new Promise((resolve, reject) => {
+            const ff = spawn(ffmpegPath, ['-y', '-i', inputPath, '-c:a', 'libopus', '-b:a', '128k', '-ar', '48000', '-ac', '1', '-vbr', 'on', '-compression_level', '10', '-frame_duration', '20', '-application', 'audio', '-map_metadata', '-1', outputPath], { stdio: ['ignore', 'ignore', 'pipe'] })
+            ff.on('close', code => code === 0 ? resolve() : reject(new Error(`FFmpeg Opus exited with code ${code}`)))
             ff.on('error', reject)
         })
+        return await fs.readFile(outputPath)
     } finally {
         try { await fs.unlink(inputPath) } catch { }
+        try { await fs.unlink(outputPath) } catch { }
     }
 }
 
 const convertToMp4Buffer = async (buffer, logger) => {
     const ffmpegPath = await getFfmpegPath()
-    return new Promise((resolve, reject) => {
-        const ff = spawn(ffmpegPath, ['-i', 'pipe:0', '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '23', '-c:a', 'aac', '-b:a', '128k', '-movflags', 'faststart', '-f', 'mp4', 'pipe:1'], { stdio: ['pipe', 'pipe', 'pipe'] })
-        const chunks = []
-        ff.stdin.write(buffer)
-        ff.stdin.end()
-        ff.stdout.on('data', chunk => chunks.push(chunk))
-        ff.stderr.on('data', () => { })
-        ff.on('close', code => code === 0 ? resolve(Buffer.concat(chunks)) : reject(new Error(`FFmpeg MP4 exited with code ${code}`)))
-        ff.on('error', reject)
-    })
+    const inputPath = join(osTmpdir(), 'mp4-in-' + generateMessageIDV2())
+    const outputPath = join(osTmpdir(), 'mp4-out-' + generateMessageIDV2() + '.mp4')
+    await fs.writeFile(inputPath, buffer)
+    try {
+        await new Promise((resolve, reject) => {
+            const ff = spawn(ffmpegPath, ['-y', '-i', inputPath, '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '23', '-pix_fmt', 'yuv420p', '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2', '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', '-map_metadata', '-1', outputPath], { stdio: ['ignore', 'ignore', 'pipe'] })
+            ff.on('close', code => code === 0 ? resolve() : reject(new Error(`FFmpeg MP4 exited with code ${code}`)))
+            ff.on('error', reject)
+        })
+        return await fs.readFile(outputPath)
+    } finally {
+        try { await fs.unlink(inputPath) } catch { }
+        try { await fs.unlink(outputPath) } catch { }
+    }
 }
 
 // ─── STREAM UTILS ─────────────────────────────────────────────────────────────

package/lib/Utils/messages.js

@@ -317,9 +317,11 @@ const handleButtonReply = (message) => {
 
 // ─── MAIN GENERATOR ───────────────────────────────────────────────────────────
 export const generateWAMessageContent = async (message, options = {}) => {
-    const messageKeys = Object.keys(message)
+    const messageKeys = (message && typeof message === 'object') ? Object.keys(message) : []
     const isRawProtoMessage = messageKeys.some(k => k.endsWith('Message') && typeof message[k] === 'object' && !HIGH_LEVEL_KEYS.includes(k))
-    const isWrapperMessage = ['viewOnceMessage', 'ephemeralMessage', 'viewOnceMessageV2', 'documentWithCaptionMessage'].some(k => k in message)
+    const isWrapperMessage = (message && typeof message === 'object')
+        ? ['viewOnceMessage', 'ephemeralMessage', 'viewOnceMessageV2', 'documentWithCaptionMessage'].some(k => k in message)
+        : false
     if ((isRawProtoMessage || isWrapperMessage) && messageKeys.length === 1) return WAProto.Message.create(message)
     if (!messageKeys.some(k => HIGH_LEVEL_KEYS.includes(k)) && isRawProtoMessage) return WAProto.Message.create(message)
 

package/lib/Utils/tc-token-utils.js

@@ -1,17 +1,38 @@
 import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
-import { migrateIndexKey, TC_TOKEN_INDEX_KEY } from '../Utils/index.js';
-
+import { TC_TOKEN_INDEX_KEY, unixTimestampSeconds } from '../Utils/index.js';
+import { randomBytes } from 'crypto'
 // Same phone-number pattern as WABinary's isJidBot, applied against the user
 // part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
 const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
 
+const generateTcToken = () => {
+    const bucket = Math.floor(unixTimestampSeconds() / 604800)
+    const bucketByte = (bucket - 2900) & 0xff
+    return Buffer.concat([
+        Buffer.from([0x04, 0x01, bucketByte]),
+        randomBytes(8)
+    ])
+}
+
+export const preSeedTcToken = async ({ authState, jid, getLIDForPN, logger }) => {
+    const tcTokenJid = await resolveTcTokenJid(jid, getLIDForPN)
+    const existing = await authState.keys.get('tctoken', [tcTokenJid])
+    if (existing[tcTokenJid]?.token?.length) return { token: existing[tcTokenJid].token, storageJid: tcTokenJid }
+    const token = generateTcToken()
+    const timestamp = String(unixTimestampSeconds())
+    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid])
+    const existingEntry = existing[tcTokenJid] || {}
+    await authState.keys.set({ tctoken: { [tcTokenJid]: { ...existingEntry, token, timestamp }, ...indexWrite } })
+    logger?.debug({ jid, tcTokenJid }, 'pre-seeded locally generated tctoken')
+    return { token, storageJid: tcTokenJid }
+}
 /**
  * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
  * storage against malformed notifications — WA Web filters server-side but we
  * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
  * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
  */
-function isRegularUser(jid) {
+export function isRegularUser(jid) {
     if (!jid) return false;
     const user = jid.split('@')[0] ?? '';
     if (user === '0') return false; // PSA
@@ -23,20 +44,33 @@ function isRegularUser(jid) {
 const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
 const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
 
-/** Read the persisted tctoken JID index and return its entries. */
 export async function readTcTokenIndex(keys) {
-    const batch = await migrateIndexKey(keys, 'tctoken');
-    return Object.keys(batch).filter(j => j && j !== TC_TOKEN_INDEX_KEY);
+    // Try new sentinel key first, fall back to old 'index' key
+    for (const key of [TC_TOKEN_INDEX_KEY, 'index']) {
+        const data = await keys.get('tctoken', [key])
+        const entry = data[key]
+        if (!entry?.token?.length) continue
+        try {
+            const parsed = JSON.parse(Buffer.from(entry.token).toString())
+            if (!Array.isArray(parsed)) continue
+            return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY && j !== 'index')
+        } catch {
+            continue
+        }
+    }
+    return []
 }
 
-/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the index key. */
 export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
-    const batch = await migrateIndexKey(keys, 'tctoken');
-    const merged = { ...batch };
-    for (const jid of addedJids) { if (jid && jid !== TC_TOKEN_INDEX_KEY) merged[jid] = merged[jid] || true; }
-    return { [TC_TOKEN_INDEX_KEY]: merged };
+    const persisted = await readTcTokenIndex(keys)
+    const merged = new Set(persisted)
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY && jid !== 'index') merged.add(jid)
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    }
 }
-
 // WA Web has separate sender/receiver AB props for these but they're identical today
 export function isTcTokenExpired(timestamp) {
     if (timestamp === null || timestamp === undefined) return true;
@@ -59,9 +93,10 @@ export function shouldSendNewTcToken(senderTimestamp) {
 
 /** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
 export async function resolveTcTokenJid(jid, getLIDForPN) {
-    if (isLidUser(jid)) return jid;
-    const lid = await getLIDForPN(jid);
-    return lid ?? jid;
+    if (isLidUser(jid)) return jid
+    const lid = await getLIDForPN(jid)
+    if (!lid) return null
+    return lid
 }
 
 /** Resolve target JID for issuing privacy token based on AB prop 14303 */