@zervonex/baileys 3.0.3 → 3.0.5

package/README.md

@@ -73,6 +73,7 @@
   - [AI Rich Messages](#ai-rich-messages)
   - [Status & Stories](#personal-status--story-statusbroadcast)
   - [Sticker Pack](#sticker-pack)
+    - [Premium Stickers](#premium-stickers)
   - [Shorthand Wrappers](#shorthand-wrappers)
 - [Message Modifications](#️-message-modifications)
 - [Media Download](#-media-download)
@@ -343,7 +344,6 @@ autoFollowNewsletter: false,  // default: true
 })
 ```
 ---
-
 ## 💾 Session Management
 
 Two adapters are available. They do **not** share an identical return shape — see the differences noted below each.
@@ -377,7 +377,7 @@ Universal adapter for any database backend via [Keyv](https://github.com/jaredwr
 
 Storage format matches `useMultiFileAuthState` exactly: every value is wrapped as `{ data, __checksum }` with a sha256 integrity check, so corruption is detected and self-healed the same way on both adapters. Reads also auto-detect and repair values that were written by an older/buggy version of this adapter (including arbitrarily nested `{ value: { value: ... } }` wrapping) — no manual data-fixing needed if you're upgrading from an earlier release.
 
-The first argument is the **session ID** — equivalent to the folder name in `useMultiFileAuthState`. It's used as the Keyv namespace, so multiple bots can safely share one backend. The second argument is a connection string, a pre-built `Keyv` instance, or a raw `KeyvStoreAdapter`:
+The first argument is the **session ID** — equivalent to the folder name in `useMultiFileAuthState`. It's used as a key prefix (`sessionId::key`), so multiple bots can safely share one backend. The second argument is a connection string, a pre-built `Keyv` instance, or a raw `KeyvStoreAdapter`:
 
 ```javascript
 import { useKeyvAuthState } from '@zervonex/baileys'
@@ -440,7 +440,19 @@ const { state, saveCreds, clearSession } = await useKeyvAuthState('bot1', 'redis
 await clearSession()
 ```
 
-`clearSession()` wipes every key belonging to that `sessionId` — creds, prekeys, sessions, sender keys, everything — using each backend's native namespace-scoped bulk delete (a real `deleteMany`/`DELETE WHERE`/`SCAN`+delete under the hood, not a per-key loop). It only affects this session; other sessions sharing the same backend are untouched. There's no equivalent method on `useMultiFileAuthState` — delete the session folder instead.
+`clearSession()` wipes every key belonging to that `sessionId` — creds, prekeys, sessions, sender keys, everything — by iterating the store filtering by the `sessionId::` prefix and calling `deleteMany`. Only this session's keys are removed; other sessions sharing the same backend are untouched. There is no equivalent method on `useMultiFileAuthState` — delete the session folder instead.
+
+#### Checking auth without loading full state
+
+```javascript
+import { hasKeyvAuth } from '@zervonex/baileys'
+
+// Check if a session has valid auth (lightweight — no full state load)
+const valid = await hasKeyvAuth('bot1', backend)
+// true if creds exist and contain noiseKey + signedIdentityKey
+```
+
+`hasKeyvAuth()` queries the backend using the correct key prefix — the same way `useKeyvAuthState` does internally — so it always returns the right answer regardless of your backend. Useful for checking session ownership before deciding whether to restore a connection, without the overhead of initializing a full auth state.
 
 #### Options
 
@@ -1363,6 +1375,23 @@ await sock.stickerPackMessage(jid, {
 }, { quoted: message })
 ```
 
+### Premium Stickers
+
+Pass `premium` on a single sticker:
+```js
+await sock.sendMessage(jid, { sticker: buffer, premium: 1 })
+```
+
+Per-sticker in a pack:
+```js
+await sock.sendMessage(jid, { stickerPack: { stickers: [{ data: buffer, emojis: ['🔥'], premium: 1 }] } })
+```
+
+Whole pack as premium:
+```js
+await sock.sendMessage(jid, { stickerPack: { premium: 1, stickers: [...] } })
+```
+
 **Per-sticker options:**
 
 | Field | Type | Default | Description |
@@ -2961,6 +2990,7 @@ import {
   makeWASocket,
   useMultiFileAuthState,
   useKeyvAuthState,
+  hasKeyvAuth,
   makeCacheableSignalKeyStore,
   Browsers,
   DisconnectReason,

package/WAProto/WAProtoCompile.js

@@ -255,6 +255,7 @@ function makeProto(tablePath) {
         node.toObject = o => o ?? {}
         node.verify = () => null
         node.name = full.split('.').pop()
+        node.fields = Object.fromEntries(TABLE[full].order.map(f => [f.name, { type: f.s ?? f.k, id: f.id, repeated: f.rep ?? false }]))
     }
     for (const [full, values] of Object.entries(e)) {
         const node = nodeFor(full.replace(/^proto\./, '').split('.'))

package/WAProto/fetcher.js

@@ -1,69 +1,53 @@
 import { fetch, Agent } from 'undici'
 import { createHash } from 'crypto'
-import { readFileSync, writeFileSync, existsSync } from 'fs'
+import { readFileSync, writeFileSync, existsSync, createWriteStream, unlinkSync } from 'fs'
+import { pipeline } from 'stream/promises'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const CACHE_FILE = join(__dirname, '.cache.json')
 const PROTO_FILE = join(__dirname, 'WAProto.proto')
-
+const BUNDLE_TMP = join(__dirname, 'WAProto.bundle.tmp')
 const GITHUB_RAW = 'https://raw.githubusercontent.com/nexustechpro2/baileys/wa-cache'
 const CACHE_TTL = 24 * 60 * 60 * 1000
-
-const agent = new Agent({ connect: { family: 4 } })
+const agent = new Agent({ connect: { family: 4, timeout: 60000 } })
 
 const isCacheValid = (cache) => cache.version && cache.timestamp && (Date.now() - cache.timestamp) < CACHE_TTL
 const readCache = () => { try { return existsSync(CACHE_FILE) ? JSON.parse(readFileSync(CACHE_FILE, 'utf8')) : {} } catch { return {} } }
 const writeCache = (data) => writeFileSync(CACHE_FILE, JSON.stringify({ ...data, timestamp: Date.now() }, null, 2), 'utf8')
+const removeTmp = () => { try { if (existsSync(BUNDLE_TMP)) unlinkSync(BUNDLE_TMP) } catch { } }
 
 async function fetchFromGitHub(file) {
     const res = await fetch(`${GITHUB_RAW}/${file}`, { method: 'GET', dispatcher: agent })
     if (!res.ok) throw new Error(`[WAProto] GitHub fetch failed: ${res.status} for ${file}`)
-    return file.endsWith('.json') ? res.json() : res.text()
+    if (file.endsWith('.json')) return res.json()
+    const hash = createHash('sha256')
+    const writer = createWriteStream(BUNDLE_TMP)
+    await pipeline(res.body, async function* (source) { for await (const chunk of source) { hash.update(chunk); yield chunk } }, writer)
+    return hash.digest('hex')
 }
 
 async function fetchClientRevision() {
     const data = await fetchFromGitHub('wa-version.json')
-    if (!data?.version) throw new Error('[WAProto] GitHub wa-version.json missing version field')
+    if (!data?.version) throw new Error('[WAProto] wa-version.json missing version field')
     return String(data.version)
 }
 
-async function fetchCombinedBundle() {
-    return fetchFromGitHub('WAProto.bundle.js')
-}
-
 export async function fetchProtoBundle() {
     const cache = readCache()
     if (isCacheValid(cache) && existsSync(PROTO_FILE)) return { changed: false, bundle: null, version: cache.version }
-
     const version = await fetchClientRevision()
-
-    if (cache.version === version && existsSync(PROTO_FILE)) {
-        writeCache({ ...cache, version })
-        return { changed: false, bundle: null, version }
-    }
-
-    let bundle = await fetchCombinedBundle()
-    const hash = createHash('sha256').update(bundle).digest('hex')
-
-    if (cache.hash === hash) {
-        writeCache({ version, hash })
-        return { changed: false, bundle: null, version }
-    }
-
+    if (cache.version === version && existsSync(PROTO_FILE)) { writeCache({ ...cache, version }); return { changed: false, bundle: null, version } }
+    const hash = await fetchFromGitHub('WAProto.bundle.js')
+    if (cache.hash === hash) { writeCache({ version, hash }); removeTmp(); return { changed: false, bundle: null, version } }
     writeCache({ version, hash })
-    const result = { changed: true, bundle, version }
-    bundle = null
-    return result
+    return { changed: true, bundlePath: BUNDLE_TMP, version }
 }
 
 export async function getWAVersion() {
     const cache = readCache()
     if (isCacheValid(cache) && cache.version) return [2, 3000, parseInt(cache.version)]
-
-    const data = await fetchFromGitHub('wa-version.json')
-    if (!data?.version) throw new Error('[WAProto] GitHub wa-version.json missing version field')
-
-    return [2, 3000, parseInt(data.version)]
+    const version = await fetchClientRevision()
+    return [2, 3000, parseInt(version)]
 }

package/WAProto/index.js

@@ -1,6 +1,7 @@
 import { existsSync, unlinkSync, readFileSync } from 'fs'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
+import { Worker, isMainThread, workerData, parentPort } from 'worker_threads'
 import logger from '../lib/Utils/logger.js'
 import { fetchProtoBundle } from './fetcher.js'
 import { generateTable, _reloadProto } from './WAProtoCompile.js'
@@ -9,37 +10,33 @@ import { parseBundle } from './parser.js'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const PROTO_FILE = join(__dirname, 'WAProto.proto')
 const TABLE_FILE = join(__dirname, 'WAProto.json')
+const SELF = new URL(import.meta.url)
 
 const log = msg => logger.info(msg)
 const err = msg => logger.error(msg)
+const del = (...files) => { for (const f of files) { try { if (existsSync(f)) unlinkSync(f) } catch { } } }
+const isJsonValid = () => { try { const { m, t } = JSON.parse(readFileSync(TABLE_FILE, 'utf8')); return Array.isArray(m) && m.length > 0 && typeof t === 'object' && Object.keys(t).length > 0 } catch { return false } }
 
-const isJsonValid = () => {
-    try {
-        const { m, t } = JSON.parse(readFileSync(TABLE_FILE, 'utf8'))
-        return Array.isArray(m) && m.length > 0 && typeof t === 'object' && Object.keys(t).length > 0
-    } catch { return false }
+function runInWorker(data) {
+    return new Promise((resolve, reject) => {
+        const w = new Worker(SELF, { workerData: data })
+        w.once('message', msg => { w.terminate(); msg.ok ? resolve() : reject(new Error(msg.error)) })
+        w.once('error', reject)
+    })
 }
 
-const del = (...files) => { for (const f of files) { try { if (existsSync(f)) unlinkSync(f) } catch { } } }
-
 async function regenerateFromProto() {
     log('Regenerating WAProto.json from existing WAProto.proto...')
-    await generateTable(PROTO_FILE, TABLE_FILE)
+    await runInWorker({ bundlePath: null, version: null, protoPath: PROTO_FILE, tablePath: TABLE_FILE })
     _reloadProto()
     log('Regenerated successfully')
 }
 
 async function refetch() {
     log('Fetching proto bundle from GitHub...')
-    const { bundle, version } = await fetchProtoBundle()
-    if (!bundle) throw new Error('fetchProtoBundle returned no bundle')
-    const protoText = parseBundle(bundle, version)
-    const { writeFileSync } = await import('fs')
-    const tmp = PROTO_FILE + '.tmp'
-    writeFileSync(tmp, protoText, 'utf8')
-    const { renameSync } = await import('fs')
-    renameSync(tmp, PROTO_FILE)
-    await generateTable(PROTO_FILE, TABLE_FILE)
+    const { bundle, bundlePath, version } = await fetchProtoBundle()
+    if (!bundle && !bundlePath) throw new Error('fetchProtoBundle returned no bundle')
+    await runInWorker({ bundlePath: bundlePath ?? null, bundle: bundle ?? null, version, protoPath: PROTO_FILE, tablePath: TABLE_FILE })
     _reloadProto()
     log(`Fetched and compiled — WA version ${version}`)
 }
@@ -59,7 +56,6 @@ async function boot() {
         }
         return
     }
-
     if (hasProto && !hasJson) {
         log('WAProto.json missing — generating from existing proto...')
         try { await regenerateFromProto(); return } catch (e) {
@@ -69,19 +65,31 @@ async function boot() {
         }
         return
     }
-
-    if (hasJson && !hasProto) {
-        err('WAProto.proto missing but WAProto.json exists — cannot trust JSON, refetching...')
-        del(TABLE_FILE)
-        await refetch()
-        return
-    }
+    if (hasJson && !hasProto) { err('WAProto.proto missing but WAProto.json exists — cannot trust JSON, refetching...'); del(TABLE_FILE); await refetch(); return }
 
     log('No proto files found — fetching from GitHub...')
     await refetch()
 }
 
-await boot()
+if (!isMainThread) {
+    const { bundlePath, bundle, version, protoPath, tablePath } = workerData
+    try {
+        if (bundlePath || bundle) {
+            const src = bundlePath ? readFileSync(bundlePath, 'utf8') : bundle
+            if (bundlePath) unlinkSync(bundlePath)
+            const { writeFileSync, renameSync } = await import('fs')
+            const tmp = protoPath + '.tmp'
+            writeFileSync(tmp, parseBundle(src, version), 'utf8')
+            renameSync(tmp, protoPath)
+        }
+        await generateTable(protoPath, tablePath)
+        parentPort.postMessage({ ok: true })
+    } catch (e) {
+        parentPort.postMessage({ ok: false, error: e.message })
+    }
+} else {
+    await boot()
+}
 
 export { proto, codec, generateTable, _reloadProto } from './WAProtoCompile.js'
 export { getWAVersion, fetchProtoBundle } from './fetcher.js'