@zervonex/baileys 0.0.0-stage → 3.0.2

package/WAProto/WAProtoCompile.js

@@ -0,0 +1,291 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs'
+import { fileURLToPath } from 'url'
+import Long from 'long'
+
+const MAXSAFE = 0x1fffffffffffff
+
+const KIND = [
+    { k: 'varint', s: 'int' }, { k: 'varint', s: 'zigzag' }, { k: 'varint', s: 'bool' },
+    { k: 'i64', s: 'long' }, { k: 'i64', s: 'double' }, { k: 'i32', s: 'int' }, { k: 'i32', s: 'float' },
+    { k: 'string' }, { k: 'bytes' }, { k: 'varint', s: 'enum' }, { k: 'varint', s: 'long' }, { k: 'varint', s: 'zigzaglong' },
+]
+
+const SCALAR_TC = {
+    int32: 0, uint32: 0, sint32: 1, bool: 2, fixed64: 3, sfixed64: 3, double: 4,
+    fixed32: 5, sfixed32: 5, float: 6, string: 7, bytes: 8, int64: 10, uint64: 10, sint64: 11,
+}
+
+const isLongLike = v => v !== null && typeof v === 'object' && 'low' in v && 'high' in v
+const longToBigInt = v => (v.unsigned ? BigInt(v.high >>> 0) : BigInt(v.high | 0)) * 4294967296n + BigInt(v.low >>> 0)
+const anyToBigInt = v => typeof v === 'bigint' ? v : isLongLike(v) ? longToBigInt(v) : BigInt(Math.trunc(Number(v)))
+const zigzagEncode = v => BigInt.asUintN(64, anyToBigInt(v) << 1n ^ anyToBigInt(v) >> 63n)
+const numOrBigInt = b => b <= 9007199254740991n && b >= -9007199254740991n ? Number(b) : b
+const toLong = big => Long.fromString(BigInt.asIntN(64, big).toString())
+const wireType = f => f.k === 'varint' ? 0 : f.k === 'i64' ? 1 : f.k === 'i32' ? 5 : 2
+
+const toBuffer = v => {
+    if (v == null) return Buffer.alloc(0)
+    if (Buffer.isBuffer(v)) return v
+    if (typeof v === 'string') return Buffer.from(v, 'base64')
+    if (v?.type === 'Buffer' && Array.isArray(v.data)) return Buffer.from(v.data)
+    if (v instanceof Uint8Array) return Buffer.from(v)
+    if (typeof v === 'object') return Buffer.from(JSON.stringify(v))
+    return Buffer.alloc(0)
+}
+
+const B64_JSON = function () { return this.toString('base64') }
+const tagBytes = b => (Object.defineProperty(b, 'toJSON', { value: B64_JSON, enumerable: false, configurable: true }), b)
+
+class Writer {
+    constructor() { this.buf = new Uint8Array(256); this.len = 0 }
+    _grow(n) {
+        if (this.len + n <= this.buf.length) return
+        let cap = this.buf.length * 2
+        while (cap < this.len + n) cap *= 2
+        const next = new Uint8Array(cap)
+        next.set(this.buf.subarray(0, this.len))
+        this.buf = next
+    }
+    byte(b) { this._grow(1); this.buf[this.len++] = b }
+    raw(u) { this._grow(u.length); this.buf.set(u, this.len); this.len += u.length }
+    tag(f, wire) { this.varintNum(f * 8 + wire) }
+    varintNum(n) { this._grow(10); while (n > 0x7f) { this.buf[this.len++] = (n & 0x7f) | 0x80; n = Math.floor(n / 128) }; this.buf[this.len++] = n }
+    varintBig(v) { this._grow(10); let n = BigInt.asUintN(64, v); while (n > 0x7fn) { this.buf[this.len++] = Number((n & 0x7fn) | 0x80n); n >>= 7n }; this.buf[this.len++] = Number(n) }
+    vint(v) { typeof v === 'number' && v >= 0 && v <= MAXSAFE && Number.isInteger(v) ? this.varintNum(v) : this.varintBig(anyToBigInt(v)) }
+    fixed32(v) { this._grow(4); const n = Number(BigInt.asUintN(32, anyToBigInt(v))) >>> 0; this.buf[this.len++] = n & 0xff; this.buf[this.len++] = (n >>> 8) & 0xff; this.buf[this.len++] = (n >>> 16) & 0xff; this.buf[this.len++] = (n >>> 24) & 0xff }
+    fixed64(v) { this._grow(8); const b = Buffer.allocUnsafe(8); b.writeBigUInt64LE(BigInt.asUintN(64, anyToBigInt(v))); this.raw(b) }
+    float(v) { this._grow(4); const b = Buffer.allocUnsafe(4); b.writeFloatLE(v); this.raw(b) }
+    double(v) { this._grow(8); const b = Buffer.allocUnsafe(8); b.writeDoubleLE(v); this.raw(b) }
+    finish() { return Buffer.from(this.buf.buffer, this.buf.byteOffset, this.len) }
+}
+
+class Reader {
+    constructor(buf) { this.buf = Buffer.isBuffer(buf) ? buf : Buffer.from(buf); this.p = 0; this.len = this.buf.length }
+    _check(n) { if (this.p + n > this.len) throw new RangeError(`[WAProto] buffer overread: need ${n} bytes at ${this.p}, have ${this.len - this.p}`) }
+    varint() {
+        let r = 0, mult = 1, b, n = 0
+        do {
+            if (this.p >= this.len) throw new RangeError('[WAProto] varint: unexpected end of buffer')
+            b = this.buf[this.p++]; r += (b & 0x7f) * mult; mult *= 128; n++
+            if (n > 10) throw new RangeError('[WAProto] varint: too many bytes')
+        } while (b & 0x80)
+        return r > Number.MAX_SAFE_INTEGER ? Number(BigInt.asIntN(64, BigInt(Math.trunc(r)))) : r
+    }
+    varintBig() {
+        let r = 0n, s = 0n, b, n = 0
+        do {
+            if (this.p >= this.len) throw new RangeError('[WAProto] varintBig: unexpected end of buffer')
+            b = this.buf[this.p++]; r |= BigInt(b & 0x7f) << s; s += 7n; n++
+            if (n > 10) throw new RangeError('[WAProto] varintBig: too many bytes')
+        } while (b & 0x80)
+        return r
+    }
+    skipVarint() { let n = 0; while (this.p < this.len && this.buf[this.p++] & 0x80) { if (++n > 10) throw new RangeError('[WAProto] skipVarint overflow') } }
+    u32() { this._check(4); const p = this.p; this.p += 4; return (this.buf[p] | this.buf[p + 1] << 8 | this.buf[p + 2] << 16 | this.buf[p + 3] << 24) >>> 0 }
+    slice(len) { if (len < 0 || this.p + len > this.len) throw new RangeError(`[WAProto] slice: invalid length ${len} at ${this.p}`); const s = this.buf.subarray(this.p, this.p + len); this.p += len; return s }
+    read8() { this._check(8); const b = this.buf.subarray(this.p, this.p + 8); this.p += 8; return b }
+    read4() { this._check(4); const b = this.buf.subarray(this.p, this.p + 4); this.p += 4; return b }
+}
+
+function buildTable(rawTable, msgNames) {
+    const TABLE = {}
+    for (const [full, fields] of Object.entries(rawTable)) {
+        const order = fields.map(([name, id, tc, flags = 0, enumName]) => {
+            const base = tc >= 100 ? { k: 'msg', msg: msgNames[tc - 100] } : KIND[tc]
+            const f = { name, id, ...base, rep: !!(flags & 1), packed: !!(flags & 2) }
+            if (tc === 9 && enumName) f.enumName = enumName
+            return f
+        })
+        TABLE[full] = { order, byId: Object.fromEntries(order.map(f => [f.id, f])) }
+    }
+    return TABLE
+}
+
+function makeCodec(TABLE, enumIndex) {
+    function resolveEnum(f, v) {
+        if (typeof v !== 'string') return v
+        if (f.enumName && enumIndex[f.enumName]) { const n = enumIndex[f.enumName][v]; if (n !== undefined) return n }
+        const n = Number(v)
+        return Number.isFinite(n) ? n : undefined
+    }
+
+    function writeScalar(w, f, v) {
+        switch (f.k) {
+            case 'varint':
+                if (f.s === 'bool') w.byte(v ? 1 : 0)
+                else if (f.s === 'zigzag' || f.s === 'zigzaglong') w.varintBig(zigzagEncode(v))
+                else w.vint(v)
+                break
+            case 'i64': f.s === 'double' ? w.double(v) : w.fixed64(v); break
+            case 'i32': f.s === 'float' ? w.float(v) : w.fixed32(v); break
+            case 'string': { const b = Buffer.from(String(v), 'utf8'); w.varintNum(b.length); w.raw(b); break }
+            case 'bytes': { const b = toBuffer(v); w.varintNum(b.length); w.raw(b); break }
+            case 'msg': { const s = new Writer(); encodeMsg(s, TABLE[f.msg], v); const b = s.finish(); w.varintNum(b.length); w.raw(b); break }
+        }
+    }
+
+    function encodeMsg(w, T, obj) {
+        if (!T) throw new Error('[WAProto] Unknown message in table')
+        for (const f of T.order) {
+            let v = obj[f.name]
+            if (v == null) continue
+            if (f.s === 'enum') {
+                if (f.rep) { v = (Array.isArray(v) ? v : [v]).map(x => resolveEnum(f, x)).filter(x => x !== undefined); if (!v.length) continue }
+                else { v = resolveEnum(f, v); if (v === undefined) continue }
+            }
+            if (f.rep) {
+                if (!Array.isArray(v)) v = [v]
+                if (f.packed && (f.k === 'varint' || f.k === 'i64' || f.k === 'i32')) {
+                    const s = new Writer()
+                    for (const item of v) writeScalar(s, f, item)
+                    const b = s.finish()
+                    w.tag(f.id, 2); w.varintNum(b.length); w.raw(b)
+                } else { const wt = wireType(f); for (const item of v) { w.tag(f.id, wt); writeScalar(w, f, item) } }
+            } else { w.tag(f.id, wireType(f)); writeScalar(w, f, v) }
+        }
+    }
+
+    function readScalar(r, f) {
+        switch (f.k) {
+            case 'varint': {
+                if (f.s === 'bool') return !!r.varint()
+                if (f.s === 'zigzag') { const u = r.varintBig(); return numOrBigInt(u >> 1n ^ -(u & 1n)) }
+                if (f.s === 'zigzaglong') { const u = r.varintBig(); return toLong(u >> 1n ^ -(u & 1n)) }
+                if (f.s === 'enum') return r.varint() | 0
+                if (f.s === 'long') return toLong(BigInt(r.varint()))
+                return r.varint()
+            }
+            case 'i64': { const b = Buffer.from(r.read8()); return f.s === 'double' ? b.readDoubleLE(0) : toLong(b.readBigUInt64LE(0)) }
+            case 'i32': { if (f.s === 'float') { const b = Buffer.from(r.read4()); return b.readFloatLE(0) }; return r.u32() }
+            case 'string': { const len = r.varint(); return Buffer.from(r.slice(len)).toString('utf8') }
+            case 'bytes': return tagBytes(Buffer.from(r.slice(r.varint())))
+            case 'msg': return decodeMsg(f.msg, r.slice(r.varint()))
+        }
+    }
+
+    function skip(r, wire) {
+        if (wire === 0) r.skipVarint()
+        else if (wire === 2) { const n = r.varint(); r.slice(n) }
+        else if (wire === 1) r.read8()
+        else if (wire === 5) r.read4()
+    }
+
+    function decodeMsg(msgName, buf) {
+        const T = TABLE[msgName]
+        if (!T) throw new Error(`[WAProto] Unknown message: ${msgName}`)
+        const obj = {}, r = new Reader(buf)
+        while (r.p < r.len) {
+            let tag, id, wire
+            try { tag = r.varint(); id = tag >>> 3; wire = tag & 7 } catch { break }
+            const f = T.byId[id]
+            if (!f) { try { skip(r, wire) } catch { break }; continue }
+            try {
+                if (f.rep && wire === 2 && (f.k === 'varint' || f.k === 'i64' || f.k === 'i32')) {
+                    const len = r.varint(), end = r.p + len
+                    const arr = obj[f.name] || (obj[f.name] = [])
+                    while (r.p < end) arr.push(readScalar(r, f))
+                } else {
+                    const val = readScalar(r, f)
+                    if (f.rep) (obj[f.name] || (obj[f.name] = [])).push(val)
+                    else obj[f.name] = val
+                }
+            } catch { break }
+        }
+        return obj
+    }
+
+    return {
+        encode: (msgName, obj) => { const w = new Writer(); encodeMsg(w, TABLE[msgName], obj ?? {}); return w.finish() },
+        decode: (msgName, buf) => decodeMsg(msgName, buf),
+    }
+}
+
+export async function generateTable(protoPath, outPath) {
+    const pb = await import('protobufjs')
+    const protobuf = pb.default || pb
+    const root = await protobuf.load(protoPath)
+    const msgNames = []
+    const msgIndex = n => { let i = msgNames.indexOf(n); return i < 0 ? msgNames.push(n) - 1 : i }
+    const t = {}, e = {}
+    const build = ns => {
+        for (const o of Object.values(ns.nested ?? {})) {
+            const full = o.fullName.replace(/^\./, '')
+            if (o.values) e[full] = o.values
+            if (o.fieldsArray) {
+                const fs = []
+                for (const f of o.fieldsArray) {
+                    if (f.map) continue
+                    const rt = f.resolvedType
+                    let tc, enumName
+                    if (rt?.fieldsArray !== undefined && rt?.values === undefined) tc = 100 + msgIndex(rt.fullName.replace(/^\./, ''))
+                    else if (rt?.values) { tc = 9; enumName = rt.fullName.replace(/^\./, '') }
+                    else tc = SCALAR_TC[f.type]
+                    const numeric = tc < 100 && tc !== 7 && tc !== 8
+                    const flags = (f.repeated ? 1 : 0) | (f.repeated && numeric && f.packed !== false ? 2 : 0)
+                    if (tc === 9) fs.push([f.name, f.id, 9, flags, enumName])
+                    else if (flags) fs.push([f.name, f.id, tc, flags])
+                    else fs.push([f.name, f.id, tc])
+                }
+                fs.sort((a, b) => a[1] - b[1])
+                t[full] = fs
+            }
+            if (o.nested) build(o)
+        }
+    }
+    build(root)
+    const tmp = outPath + '.tmp'
+    writeFileSync(tmp, JSON.stringify({ m: msgNames, t, e }))
+    const { renameSync } = await import('fs')
+    renameSync(tmp, outPath)
+    return { types: Object.keys(t).length, enums: Object.keys(e).length }
+}
+
+function makeProto(tablePath) {
+    const { m, t, e } = JSON.parse(readFileSync(tablePath, 'utf8'))
+    const TABLE = buildTable(t, m)
+    const codec = makeCodec(TABLE, e)
+    const proto = {}
+    const nodeFor = path => { let c = proto; for (const p of path) c = c[p] ?? (c[p] = {}); return c }
+    for (const full of Object.keys(t)) {
+        const node = nodeFor(full.replace(/^proto\./, '').split('.'))
+        node.encode = o => ({ finish: () => codec.encode(full, o ?? {}) })
+        node.decode = b => codec.decode(full, b)
+        node.create = o => o ?? {}
+        node.fromObject = o => o ?? {}
+        node.toObject = o => o ?? {}
+        node.verify = () => null
+        node.name = full.split('.').pop()
+    }
+    for (const [full, values] of Object.entries(e)) {
+        const node = nodeFor(full.replace(/^proto\./, '').split('.'))
+        for (const [k, v] of Object.entries(values)) { node[k] = v; node[v] = k }
+    }
+    return { proto, codec }
+}
+
+const isGeneratorRun = process.argv[1] && (process.argv[1] === fileURLToPath(import.meta.url) || process.argv.includes('--generate'))
+
+if (isGeneratorRun) {
+    const protoPath = fileURLToPath(new URL('./WAProto.proto', import.meta.url))
+    const outPath = fileURLToPath(new URL('./WAProto.json', import.meta.url))
+    generateTable(protoPath, outPath)
+        .then(r => { process.stdout.write(`[WAProto] Generated: ${r.types} types, ${r.enums} enums\n`); process.exit(0) })
+        .catch(err => { process.stderr.write(err.message + '\n'); process.exit(1) })
+}
+
+const tablePath = fileURLToPath(new URL('./WAProto.json', import.meta.url))
+const built = { proto: {}, codec: null }
+
+export function _reloadProto() {
+    if (!existsSync(tablePath)) return
+    const loaded = makeProto(tablePath)
+    for (const key of Object.keys(built.proto)) delete built.proto[key]
+    Object.assign(built.proto, loaded.proto)
+    built.codec = loaded.codec
+}
+
+if (!isGeneratorRun && existsSync(tablePath)) _reloadProto()
+
+export const proto = built.proto
+export const codec = built.codec
+export default built

package/WAProto/fetcher.js

@@ -0,0 +1,69 @@
+import { fetch, Agent } from 'undici'
+import { createHash } from 'crypto'
+import { readFileSync, writeFileSync, existsSync } from 'fs'
+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 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 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')
+
+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()
+}
+
+async function fetchClientRevision() {
+    const data = await fetchFromGitHub('wa-version.json')
+    if (!data?.version) throw new Error('[WAProto] GitHub 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 }
+    }
+
+    writeCache({ version, hash })
+    const result = { changed: true, bundle, version }
+    bundle = null
+    return result
+}
+
+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)]
+}

package/WAProto/index.js

@@ -0,0 +1,88 @@
+import { existsSync, unlinkSync, readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import logger from '../lib/Utils/logger.js'
+import { fetchProtoBundle } from './fetcher.js'
+import { generateTable, _reloadProto } from './WAProtoCompile.js'
+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 log = msg => logger.info(msg)
+const err = msg => logger.error(msg)
+
+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 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)
+    _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)
+    _reloadProto()
+    log(`Fetched and compiled — WA version ${version}`)
+}
+
+async function boot() {
+    const hasProto = existsSync(PROTO_FILE)
+    const hasJson = existsSync(TABLE_FILE)
+
+    if (hasProto && hasJson) {
+        if (isJsonValid()) { _reloadProto(); return }
+        err('WAProto.json is invalid or corrupt — regenerating from proto...')
+        del(TABLE_FILE)
+        try { await regenerateFromProto(); return } catch (e) {
+            err(`Regeneration failed: ${e.message} — refetching from WA Web...`)
+            del(PROTO_FILE, TABLE_FILE)
+            await refetch()
+        }
+        return
+    }
+
+    if (hasProto && !hasJson) {
+        log('WAProto.json missing — generating from existing proto...')
+        try { await regenerateFromProto(); return } catch (e) {
+            err(`Generation failed: ${e.message} — refetching from WA Web...`)
+            del(PROTO_FILE, 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()
+
+export { proto, codec, generateTable, _reloadProto } from './WAProtoCompile.js'
+export { getWAVersion, fetchProtoBundle } from './fetcher.js'
+export { default } from './WAProtoCompile.js'