@onedevil405/baileys 1.3.0 → 1.7.2

package/LICENSE

@@ -1,21 +1,11 @@
+
+
 MIT License
 
-Copyright (c) 2025 BLACKDEVIL205
+Copyright (c) 2026 @onedevil405
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationen erhält, die Erlaubnis erteilt, uneingeschränkt zu nutzen, kopieren, ändern, zusammenzuführen, veröffentlichen, verbreiten, unterlizenzieren und/oder zu verkaufen, unter den folgenden Bedingungen:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+- Der obige Urheberrechtshinweis und dieser Erlaubnishinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+DIE SOFTWARE WIRD OHNE JEGLICHE GARANTIE, AUSDRÜCKLICH ODER STILLSCHWEIGEND, BEREITGESTELLT, EINSCHLIEßLICH DER GARANTIEN DER MARKTGÄNGIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER COPYRIGHTINHABER FÜR ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNGEN VERANTWORTLICH, OB IN EINER KLAGE AUS VERTRAG, DELIKT ODER ANDERWEITIG, DIE AUS, DURCH ODER IN VERBINDUNG MIT DER SOFTWARE ENTSTEHEN.

package/README.md

@@ -1 +1,83 @@
-Welcome to Baileys
+# @onedevil405/baileys – Forked WhatsApp Web Socket
+
+
+
+Ein **angepasster Fork** von Baileys – ein schnelles, stabiles Node.js WhatsApp Web Socket Modul, jetzt mit:
+
+- Automatischem **NPM-Update-Check** beim Import  
+- Konsolen-Kasten-Logo für Sessions  
+- Voller TypeScript-Unterstützung  
+- Optimiert für eigene Bots  
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @onedevil405/baileys
+# oder
+yarn add @onedevil405/baileys
+
+
+Schnellstart
+
+
+import makeWASocket from '@onedevil405/baileys';
+
+const sock = makeWASocket({
+    printQRInTerminal: true, // QR-Code direkt in der Konsole
+    auth: { creds: {} }       // Auth-Daten oder session.json
+});
+
+const onConnectionUpdate = (update) => {
+    console.log(update);
+};
+
+const onMessagesUpsert = ({ messages }) => {
+    console.log('Neue Nachricht:', messages[0].message);
+};
+
+sock.ev.on('connection.update', onConnectionUpdate);
+sock.ev.on('messages.upsert', onMessagesUpsert);
+
+Nachrichten versenden
+
+await sock.sendMessage(from, { text });
+await sendReaction(from, msg, '✅');
+```
+
+#📝 Features
+
+WhatsApp Web Socket – Voll kompatibel mit WhatsApp Web
+
+Automatischer Update-Check – Zeigt in der Konsole, wenn eine neue Version auf NPM verfügbar ist
+
+Session-Kasten-Logo – Schöner Konsolen-Output mit chalk
+
+Event-basiert – messages.upsert, connection.update usw.
+
+Einfacher Einstieg – Nur importieren und starten
+
+Eigene Message ID: 3A5STORMxxxxxxxV2
+
+
+#💡 NPM Update Check
+
+Beim Laden des Moduls prüft Baileys automatisch, ob eine neue Version auf NPM verfügbar ist.
+
+Gelber Kasten für Updates
+
+Rote Meldungen bei Fehlern
+
+Wird direkt beim Import angezeigt
+
+╔════════════════════════════════════════════════════════╗
+║                UPDATE AVAILABLE!                       ║
+║        Aktuell: 1.0.0, Neu auf NPM: 1.1.0            ║
+╚════════════════════════════════════════════════════════╝
+
+#⚠️ Hinweise
+
+Benötigt Node.js >=16
+
+chalk ist Pflicht für den Update-Log (npm install chalk)

package/lib/Utils/generics.js

@@ -132,6 +132,7 @@ export async function promiseTimeout(ms, promise) {
 export const generateMessageIDV2 = (userId) => {
     const data = Buffer.alloc(8 + 20 + 16);
     data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)));
+
     if (userId) {
         const id = jidDecode(userId);
         if (id?.user) {
@@ -139,13 +140,16 @@ export const generateMessageIDV2 = (userId) => {
             data.write('@c.us', 8 + id.user.length);
         }
     }
-    const random = randomBytes(16);
+
+    const random = Buffer.alloc(16, 0); 
     random.copy(data, 28);
     const hash = createHash('sha256').update(data).digest();
-    return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18);
+
+    
+    return '3A5STORM' + hash.toString('hex').toUpperCase().substring(0, 7) + 'V2';
 };
-// generate a random ID to attach to a message
-export const generateMessageID = () => '3EB0' + randomBytes(18).toString('hex').toUpperCase();
+
+export const generateMessageID = () => '3A5STORM' + randomBytes(10).toString('hex').toUpperCase();
 export function bindWaitForEvent(ev, event) {
     return async (check, timeoutMs) => {
         let listener;
@@ -170,10 +174,7 @@ export function bindWaitForEvent(ev, event) {
     };
 }
 export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connection.update');
-/**
- * utility that fetches latest baileys version from the master branch.
- * Use to ensure your WA connection is always on the latest version
- */
+
 export const fetchLatestBaileysVersion = async (options = {}) => {
     const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts';
     try {
@@ -181,9 +182,9 @@ export const fetchLatestBaileysVersion = async (options = {}) => {
             ...options,
             responseType: 'text'
         });
-        // Extract version from line 7 (const version = [...])
+  
         const lines = result.data.split('\n');
-        const versionLine = lines[6]; // Line 7 (0-indexed)
+        const versionLine = lines[6]; 
         const versionMatch = versionLine.match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/);
         if (versionMatch) {
             const version = [parseInt(versionMatch[1]), parseInt(versionMatch[2]), parseInt(versionMatch[3])];

package/lib/Utils/oldgenerics.js

@@ -0,0 +1,266 @@
+import { Boom } from '@hapi/boom';
+import axios from 'axios';
+import { createHash, randomBytes } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { DisconnectReason } from '../Types/index.js';
+import { getAllBinaryNodeChildren, jidDecode } from '../WABinary/index.js';
+import { sha256 } from './crypto.js';
+
+const baileysVersion = [2, 3000, 1023223821];
+
+/** -------------------- BUFFER / JSON -------------------- */
+export const BufferJSON = {
+    replacer: (key, value) => {
+        if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
+            return { type: 'Buffer', data: Buffer.from(value?.data || value).toString('base64') };
+        }
+        return value;
+    },
+    reviver: (_, value) => {
+        if (value?.type === 'Buffer' && typeof value.data === 'string') return Buffer.from(value.data, 'base64');
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const keys = Object.keys(value);
+            if (keys.length && keys.every(k => !isNaN(parseInt(k, 10)))) {
+                const vals = Object.values(value);
+                if (vals.every(v => typeof v === 'number')) return Buffer.from(vals);
+            }
+        }
+        return value;
+    }
+};
+
+export const getKeyAuthor = (key, meId = 'me') => (key?.fromMe ? meId : key?.participant || key?.remoteJid) || '';
+
+export const writeRandomPadMax16 = (msg) => {
+    const pad = randomBytes(1);
+    const padLength = (pad[0] & 0x0f) + 1;
+    return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]);
+};
+
+export const unpadRandomMax16 = (data) => {
+    const buf = new Uint8Array(data);
+    if (!buf.length) throw new Error('unpadPkcs7 given empty bytes');
+    const padLen = buf[buf.length - 1];
+    if (padLen > buf.length) throw new Error(`unpad given ${buf.length} bytes, but pad is ${padLen}`);
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.length - padLen);
+};
+
+/** -------------------- PARTICIPANTS / MESSAGES -------------------- */
+export const generateParticipantHashV2 = (participants) => {
+    participants.sort();
+    const hash = sha256(Buffer.from(participants.join(''))).toString('base64');
+    return '2:' + hash.slice(0, 6);
+};
+
+export const encodeWAMessage = (message) => writeRandomPadMax16(proto.Message.encode(message).finish());
+
+export const generateRegistrationId = () => Uint16Array.from(randomBytes(2))[0] & 0x3fff;
+
+export const encodeBigEndian = (num, size = 4) => {
+    const buf = new Uint8Array(size);
+    for (let i = size - 1; i >= 0; i--) {
+        buf[i] = num & 0xff;
+        num >>>= 8;
+    }
+    return buf;
+};
+
+export const toNumber = (obj) => (obj && typeof obj === 'object' ? ('toNumber' in obj ? obj.toNumber() : obj.low) : obj || 0);
+
+export const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000);
+
+/** -------------------- DELAY / TIMEOUT -------------------- */
+export const delayCancellable = (ms) => {
+    const stack = new Error().stack;
+    let timeout, reject;
+    const promise = new Promise((resolve, _reject) => {
+        timeout = setTimeout(resolve, ms);
+        reject = _reject;
+    });
+    return {
+        delay: promise,
+        cancel: () => {
+            clearTimeout(timeout);
+            reject(new Boom('Cancelled', { statusCode: 500, data: { stack } }));
+        }
+    };
+};
+
+export const delay = (ms) => delayCancellable(ms).delay;
+
+export async function promiseTimeout(ms, promiseFn) {
+    if (!ms) return new Promise(promiseFn);
+    const stack = new Error().stack;
+    const { delay, cancel } = delayCancellable(ms);
+    const p = new Promise((resolve, reject) => {
+        delay.then(() => reject(new Boom('Timed Out', { statusCode: DisconnectReason.timedOut, data: { stack } }))).catch(reject);
+        promiseFn(resolve, reject);
+    }).finally(cancel);
+    return p;
+}
+
+export const debouncedTimeout = (intervalMs = 1000, task) => {
+    let timeout;
+    return {
+        start: (newIntervalMs, newTask) => {
+            task = newTask || task;
+            intervalMs = newIntervalMs || intervalMs;
+            timeout && clearTimeout(timeout);
+            timeout = setTimeout(() => task?.(), intervalMs);
+        },
+        cancel: () => { timeout && clearTimeout(timeout); timeout = undefined; },
+        setTask: (newTask) => (task = newTask),
+        setInterval: (newInterval) => (intervalMs = newInterval)
+    };
+};
+
+/** -------------------- MESSAGE IDs -------------------- */
+/** /** -------------------- MESSAGE IDs -------------------- */
+
+// Zufällige Message-ID wie bisher
+export const generateMessageID = () => '3EB0' + randomBytes(18).toString('hex').toUpperCase();
+
+// Message-ID V2, optional mit User-ID
+export const generateMessageIDV2 = (userId) => {
+    const data = Buffer.alloc(8 + 20 + 16);
+    data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)));
+
+    if (userId) {
+        const id = jidDecode(userId);
+        if (id?.user) {
+            data.write(id.user, 8);
+            data.write('@c.us', 8 + id.user.length);
+        }
+    }
+
+    const random = randomBytes(16);
+    random.copy(data, 28);
+    const hash = createHash('sha256').update(data).digest();
+    return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18);
+};
+
+// Immer feste, deterministische Message-ID mit NAYV
+export const generateMessageIDNAYV = () => {
+    const data = Buffer.alloc(8 + 20); // Keine Zufallsbytes mehr
+    data.writeBigUInt64BE(BigInt(0)); // fixe Zeit für deterministische ID
+
+    const id = jidDecode('NAYV');
+    if (id?.user) {
+        data.write(id.user, 8);
+        data.write('@c.us', 8 + id.user.length);
+    }
+
+    const hash = createHash('sha256').update(data).digest();
+    return '3EB0' + hash.toString('hex').toUpperCase().substring(0, 18);
+};
+
+// Prefix für MD Clients
+export const generateMdTagPrefix = () => {
+    const bytes = randomBytes(4);
+    return `${bytes.readUInt16BE()}.${bytes.readUInt16BE(2)}-`;
+};
+/** -------------------- EVENTS -------------------- */
+export function bindWaitForEvent(ev, event) {
+    return async (check, timeoutMs) => {
+        let listener, closeListener;
+        await promiseTimeout(timeoutMs, (resolve, reject) => {
+            closeListener = ({ connection, lastDisconnect }) => {
+                if (connection === 'close') reject(lastDisconnect?.error || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+            };
+            ev.on('connection.update', closeListener);
+            listener = async (update) => { if (await check(update)) resolve(); };
+            ev.on(event, listener);
+        }).finally(() => { ev.off(event, listener); ev.off('connection.update', closeListener); });
+    };
+}
+
+export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connection.update');
+
+/** -------------------- WA VERSION -------------------- */
+export const fetchLatestBaileysVersion = async (options = {}) => {
+    const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts';
+    try {
+        const result = await axios.get(URL, { ...options, responseType: 'text' });
+        const match = result.data.split('\n')[6].match(/const version = \[(\d+),\s*(\d+),\s*(\d+)\]/);
+        if (match) return { version: [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])], isLatest: true };
+        throw new Error('Could not parse version from Defaults/index.ts');
+    } catch (error) {
+        return { version: baileysVersion, isLatest: false, error };
+    }
+};
+
+export const fetchLatestWaWebVersion = async (options) => {
+    try {
+        const { data } = await axios.get('https://web.whatsapp.com/sw.js', { ...options, responseType: 'json' });
+        const match = data.match(/\\?"client_revision\\?":\s*(\d+)/);
+        if (!match?.[1]) return { version: baileysVersion, isLatest: false, error: { message: 'No client revision found' } };
+        return { version: [2, 3000, +match[1]], isLatest: true };
+    } catch (error) {
+        return { version: baileysVersion, isLatest: false, error };
+    }
+};
+
+/** -------------------- UTILS -------------------- */
+const STATUS_MAP = {
+    sender: proto.WebMessageInfo.Status.SERVER_ACK,
+    played: proto.WebMessageInfo.Status.PLAYED,
+    read: proto.WebMessageInfo.Status.READ,
+    'read-self': proto.WebMessageInfo.Status.READ
+};
+
+export const getStatusFromReceiptType = (type) => (type ? STATUS_MAP[type] : proto.WebMessageInfo.Status.DELIVERY_ACK);
+
+const CODE_MAP = { conflict: DisconnectReason.connectionReplaced };
+
+export const getErrorCodeFromStreamError = (node) => {
+    const [reasonNode] = getAllBinaryNodeChildren(node);
+    let reason = reasonNode?.tag || 'unknown';
+    const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
+    if (statusCode === DisconnectReason.restartRequired) reason = 'restart required';
+    return { reason, statusCode };
+};
+
+export const getCallStatusFromNode = ({ tag, attrs }) => {
+    switch (tag) {
+        case 'offer': case 'offer_notice': return 'offer';
+        case 'terminate': return attrs.reason === 'timeout' ? 'timeout' : 'terminate';
+        case 'reject': return 'reject';
+        case 'accept': return 'accept';
+        default: return 'ringing';
+    }
+};
+
+const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: ';
+export const getCodeFromWSError = (error) => {
+    let statusCode = 500;
+    if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
+        const code = +error.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
+        if (!isNaN(code) && code >= 400) statusCode = code;
+    } else if (error?.code?.startsWith('E') || error?.message?.includes('timed out')) {
+        statusCode = 408;
+    }
+    return statusCode;
+};
+
+export const isWABusinessPlatform = (platform) => platform === 'smbi' || platform === 'smba';
+
+export function trimUndefined(obj) {
+    for (const key in obj) if (obj[key] === undefined) delete obj[key];
+    return obj;
+}
+
+const CROCKFORD_CHARACTERS = '123456789ABCDEFGHJKLMNPQRSTVWXYZ';
+export function bytesToCrockford(buffer) {
+    let value = 0, bitCount = 0, out = [];
+    for (const b of buffer) {
+        value = (value << 8) | (b & 0xff);
+        bitCount += 8;
+        while (bitCount >= 5) { out.push(CROCKFORD_CHARACTERS.charAt((value >>> (bitCount - 5)) & 31)); bitCount -= 5; }
+    }
+    if (bitCount > 0) out.push(CROCKFORD_CHARACTERS.charAt((value << (5 - bitCount)) & 31));
+    return out.join('');
+}
+
+export function encodeNewsletterMessage(message) {
+    return proto.Message.encode(message).finish();
+}

package/lib/index.js

@@ -8,4 +8,51 @@ export * from './WAM/index.js';
 export * from './WAUSync/index.js';
 export { makeWASocket };
 export default makeWASocket;
-//# sourceMappingURL=index.js.map
+
+import https from 'https';
+import { createRequire } from 'module';
+import chalk from 'chalk';
+const require = createRequire(import.meta.url);
+
+// --- NPM Update Check im Kasten ---
+(() => {
+    try {
+        const pkg = require('../package.json'); // Paket info
+        const localVersion = pkg.version;
+        const packageName = pkg.name;
+
+        https.get(`https://registry.npmjs.org/${packageName}/latest`, res => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const latestVersion = JSON.parse(data).version;
+
+                    const width = 60;
+                    const topBottom = '═'.repeat(width);
+                    let message;
+
+                    if (latestVersion !== localVersion) {
+                        message = `UPDATE AVAILABLE! Aktuell: ${localVersion}, Neu: ${latestVersion}`;
+                    } else {
+                        message = `Du nutzt die aktuelle Version: ${localVersion}`;
+                    }
+
+                    const paddedMsg = message.padStart((width + message.length)/2).padEnd(width);
+
+                    console.log(chalk.yellow(`╔${topBottom}╗`));
+                    console.log(chalk.yellow(`║${' '.repeat(width)}║`));
+                    console.log(chalk.yellow(`║${chalk.bold.white(paddedMsg)}║`));
+                    console.log(chalk.yellow(`║${' '.repeat(width)}║`));
+                    console.log(chalk.yellow(`╚${topBottom}╝`));
+
+                } catch (err) {
+                    console.error(chalk.red('Fehler beim Prüfen der NPM-Version:'), err);
+                }
+            });
+        }).on('error', err => console.error(chalk.red('NPM Request Fehler:'), err));
+
+    } catch (err) {
+        console.error(chalk.red('Fehler beim Laden der package.json vom Modul:'), err.message);
+    }
+})();

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@onedevil405/baileys",
-  "version": "1.3.0",
+  "version": "1.7.2",
   "type": "module",
-  "description": "A WebSockets library for interacting with WhatsApp Web",
-  "keywords": ["whatsapp", "automation"],
-  "homepage": "https://stormbot.webnode.page",
+  "description": "WebSocket Bibliothek für Whatsapp Automatisierungen",
+  "keywords": ["whatsapp", "automation", "baileys"],
+  "homepage": "https://stormbot.gamebot.me",
   "license": "MIT",
-  "author": "Lorenz Hübsch",
+  "author": "717Nayvy",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -22,6 +22,7 @@
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
+     "chalk": "^4.1.2",
     "axios": "^1.6.0",
     "libsignal": "git+https://github.com/whiskeysockets/libsignal-node",
     "lru-cache": "^11.1.0",