lyxe-baileys 1.0.2 → 2.0.0

package/src/Lyxe/humanizer.js

@@ -0,0 +1,45 @@
+import { delay } from '../Utils/generics.js';
+
+/**
+ * Jeda acak manusiawi (Smart Delay) untuk menghindari deteksi spam WhatsApp.
+ * @param {number} minMs Waktu minimum (ms), default 800
+ * @param {number} maxMs Waktu maksimum (ms), default 2000
+ */
+export const smartDelay = (minMs = 800, maxMs = 2000) => {
+    const duration = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+    return delay(duration);
+};
+
+/**
+ * Simulasi mengetik manusiawi (Composing presence).
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {number} [durationMs] Durasi dalam ms. Jika tidak diisi, otomatis 1500 - 3500ms.
+ */
+export const simulateTyping = async (sock, jid, durationMs) => {
+    const time = durationMs || (Math.floor(Math.random() * 2000) + 1500);
+    try {
+        await sock.sendPresenceUpdate('composing', jid);
+        await delay(time);
+        await sock.sendPresenceUpdate('paused', jid);
+    } catch {
+        // Abaikan kegagalan presence jika koneksi sedang transisi
+    }
+};
+
+/**
+ * Simulasi merekam audio manusiawi (Recording presence).
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {number} [durationMs] Durasi dalam ms, default 2000 - 4000ms.
+ */
+export const simulateRecording = async (sock, jid, durationMs) => {
+    const time = durationMs || (Math.floor(Math.random() * 2000) + 2000);
+    try {
+        await sock.sendPresenceUpdate('recording', jid);
+        await delay(time);
+        await sock.sendPresenceUpdate('paused', jid);
+    } catch {
+        // Abaikan jika presence gagal
+    }
+};

package/src/Lyxe/index.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="node" />
+import type { proto } from '../WAProto/index.js';
+import type https from 'https';
+
+export interface ViewOnceDownloadResult {
+    buffer: Buffer;
+    mediaType: 'image' | 'video' | 'audio';
+    caption: string;
+    mimetype: string;
+    fileName: string;
+}
+
+export interface GroupBypassResult {
+    jid: string;
+    status: string;
+    bypassed: boolean;
+    inviteCode?: string;
+    inviteExpiration?: number;
+}
+
+export declare const smartDelay: (minMs?: number, maxMs?: number) => Promise<void>;
+export declare const simulateTyping: (sock: any, jid: string, durationMs?: number) => Promise<void>;
+export declare const simulateRecording: (sock: any, jid: string, durationMs?: number) => Promise<void>;
+
+export declare const downloadViewOnce: (message: any, store?: any) => Promise<ViewOnceDownloadResult>;
+export declare const extractRevokedMessage: (store: any, revocationMsg: any) => any | null;
+
+export declare const readStatus: (sock: any, statusMessage: any, delayMs?: number) => Promise<any>;
+export declare const reactStatus: (sock: any, statusMessageOrKey: any, emoji?: string) => Promise<any>;
+export declare const sendStatusMention: (sock: any, content: string | object, targetJids?: string[] | string, options?: any) => Promise<any>;
+export declare const sendVoiceStatus: (sock: any, audio: Buffer | { url: string } | string, options?: any) => Promise<any>;
+
+export declare const streamMessage: (sock: any, jid: string, stream: AsyncIterable<string> | Iterable<string> | string, options?: { throttleMs?: number; initialPlaceholder?: string; quoted?: any }) => Promise<any>;
+
+export declare const sendVoiceNote: (sock: any, jid: string, audio: Buffer | { url: string } | string, quoted?: any, options?: any) => Promise<any>;
+export declare const sendImageAsSticker: (sock: any, jid: string, sticker: Buffer | { url: string } | string, quoted?: any, options?: any) => Promise<any>;
+export declare const sendHDMedia: (sock: any, jid: string, mediaContent: { image?: any; video?: any; caption?: string }, options?: any) => Promise<any>;
+
+export declare const sendVideoNote: (sock: any, jid: string, video: Buffer | { url: string } | string, options?: any) => Promise<any>;
+
+export declare const groupAddWithBypass: (sock: any, groupJid: string, participants: string[] | string, options?: { autoInvite?: boolean; caption?: string }) => Promise<GroupBypassResult[]>;
+
+export declare const CHROME_TLS_CONFIG: any;
+export declare const CHROME_BROWSER_HEADERS: Record<string, string>;
+export declare const createProxyAgent: (proxy?: string | object, customTlsOptions?: any) => https.Agent;
+
+export declare class ImmortalVault {
+    constructor(options?: { dir?: string; enabled?: boolean; maxItems?: number });
+    recordMessage(msg: any, sock: any): Promise<void>;
+    markRevoked(revokedKey: any): any | null;
+    search(query: string): any[];
+    get(msgId: string): any | null;
+    list(limit?: number): any[];
+}
+
+export declare class LyxeDashboard {
+    constructor(sock: any, options?: { port?: number });
+    start(): void;
+    stop(): void;
+}
+
+export declare class TelegramBridge {
+    constructor(sock: any, options: { token: string; teleChatId?: string | number; waTargetJid: string; prefixHeader?: string; autoStart?: boolean });
+    start(): void;
+    stop(): void;
+}
+
+export declare class PresenceRadar {
+    constructor(sock: any);
+    track(jid: string, callback?: (ev: { jid: string; status: 'online' | 'offline'; time: number; durationMs?: number }) => void): Promise<string>;
+    getHistory(jid: string): any[];
+    getStatus(jid: string): { online: boolean; lastSeen: number } | null;
+}
+
+export declare class LyxeSessionManager {
+    constructor(options?: { baseConfig?: any; createSocketFn?: any });
+    setSocketFactory(fn: (config: any) => any): void;
+    createSession(sessionId: string, customConfig?: any): Promise<any>;
+    getSession(sessionId: string): any | null;
+    hasSession(sessionId: string): boolean;
+    deleteSession(sessionId: string): Promise<boolean>;
+    listSessions(): Array<{ id: string; createdAt: Date; hasSocket: boolean }>;
+}
+
+export declare const bindLyxeHelpers: (sock: any, config?: any) => any;

package/src/Lyxe/index.js

@@ -0,0 +1,118 @@
+import { smartDelay, simulateTyping, simulateRecording } from './humanizer.js';
+import { downloadViewOnce, extractRevokedMessage } from './view-once.js';
+import { readStatus, reactStatus, sendStatusMention, sendVoiceStatus } from './status-tools.js';
+import { streamMessage } from './ai-stream.js';
+import { sendVoiceNote, sendImageAsSticker, sendHDMedia } from './media-tools.js';
+import { LyxeSessionManager } from './session-manager.js';
+import { groupAddWithBypass } from './group-bypass.js';
+import { createProxyAgent, CHROME_TLS_CONFIG, CHROME_BROWSER_HEADERS } from '../Socket/Client/proxy-agent.js';
+import { ImmortalVault } from './vault.js';
+import { LyxeDashboard } from './dashboard.js';
+import { TelegramBridge } from './telegram-bridge.js';
+import { PresenceRadar } from './radar.js';
+import { sendVideoNote } from './video-note.js';
+
+export {
+    smartDelay,
+    simulateTyping,
+    simulateRecording,
+    downloadViewOnce,
+    extractRevokedMessage,
+    readStatus,
+    reactStatus,
+    sendStatusMention,
+    sendVoiceStatus,
+    streamMessage,
+    sendVoiceNote,
+    sendImageAsSticker,
+    sendHDMedia,
+    LyxeSessionManager,
+    groupAddWithBypass,
+    createProxyAgent,
+    CHROME_TLS_CONFIG,
+    CHROME_BROWSER_HEADERS,
+    ImmortalVault,
+    LyxeDashboard,
+    TelegramBridge,
+    PresenceRadar,
+    sendVideoNote
+};
+
+/**
+ * Menyuntikkan seluruh helper Lyxe ke dalam instance socket Baileys.
+ * @param {any} sock Socket Baileys
+ * @param {any} config Konfigurasi koneksi
+ */
+export const bindLyxeHelpers = (sock, config = {}) => {
+    // 1. Smart Anti-Ban & Humanizer
+    sock.smartDelay = (minMs, maxMs) => smartDelay(minMs, maxMs);
+    sock.simulateTyping = (jid, durationMs) => simulateTyping(sock, jid, durationMs);
+    sock.simulateRecording = (jid, durationMs) => simulateRecording(sock, jid, durationMs);
+
+    // 2. Anti-Delete & View Once
+    sock.downloadViewOnce = (message, store) => downloadViewOnce(message, store);
+    sock.extractRevokedMessage = (store, revocationMsg) => extractRevokedMessage(store, revocationMsg);
+
+    // 3. Status / Story Tools
+    sock.readStatus = (statusMessage, delayMs) => readStatus(sock, statusMessage, delayMs);
+    sock.reactStatus = (statusMessageOrKey, emoji) => reactStatus(sock, statusMessageOrKey, emoji);
+    sock.sendStatusMention = (content, targetJids, options) => sendStatusMention(sock, content, targetJids, options);
+    sock.sendVoiceStatus = (audio, options) => sendVoiceStatus(sock, audio, options);
+
+    // 4. Media & Audio Tools
+    sock.sendVoiceNote = (jid, audio, quoted, options) => sendVoiceNote(sock, jid, audio, quoted, options);
+    sock.sendImageAsSticker = (jid, sticker, quoted, options) => sendImageAsSticker(sock, jid, sticker, quoted, options);
+    sock.sendHDMedia = (jid, mediaContent, options) => sendHDMedia(sock, jid, mediaContent, options);
+
+    // 5. AI Streaming
+    sock.streamMessage = (jid, stream, options) => streamMessage(sock, jid, stream, options);
+
+    // 6. Group Privacy 403 Bypass Engine
+    sock.groupAddWithBypass = (jid, participants, options) => groupAddWithBypass(sock, jid, participants, options);
+
+    // 7. Video Note Bulat (Telegram-Style PTV)
+    sock.sendVideoNote = (jid, video, options) => sendVideoNote(sock, jid, video, options);
+
+    // 8. Immortal Media & Message Vault
+    sock.vault = new ImmortalVault(config.vaultOptions || {});
+    sock.ev.on('messages.upsert', async ({ messages }) => {
+        for (const msg of messages || []) {
+            sock.vault.recordMessage(msg, sock);
+        }
+    });
+
+    // 9. Intelligence Presence Radar (Stalker Engine)
+    sock.radar = new PresenceRadar(sock);
+    sock.trackPresence = (jid, callback) => sock.radar.track(jid, callback);
+
+    // 10. Telegram to WhatsApp Bridge
+    sock.bridgeTelegram = (options) => new TelegramBridge(sock, options);
+
+    // 11. Built-in Web Cockpit Dashboard
+    sock.startDashboard = (port = 3000) => {
+        if (!sock.dashboard) {
+            sock.dashboard = new LyxeDashboard(sock, { port });
+            sock.dashboard.start();
+        }
+        return sock.dashboard;
+    };
+
+    if (config.dashboard === true) {
+        sock.startDashboard(config.dashboardPort || 3000);
+    }
+
+    // Otomatis inject opsi simulateTyping di sendMessage jika diaktifkan
+    const originalSendMessage = sock.sendMessage.bind(sock);
+    sock.sendMessage = async (jid, content, options = {}) => {
+        if (options.simulateTyping) {
+            const textLen = (typeof content === 'string' ? content : content?.text || '').length;
+            const duration = typeof options.simulateTyping === 'number'
+                ? options.simulateTyping
+                : Math.min(Math.max(textLen * 35, 1200), 4000);
+            await sock.simulateTyping(jid, duration);
+        }
+        return originalSendMessage(jid, content, options);
+    };
+
+    return sock;
+};

package/src/Lyxe/media-tools.js

@@ -0,0 +1,67 @@
+import { getAudioWaveform } from '../Utils/messages-media.js';
+
+/**
+ * Mengirim pesan audio sebagai Voice Note (PTT) asli dengan animasi gelombang suara.
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {Buffer|{ url: string }|string} audio Buffer audio atau URL file audio
+ * @param {any} [quoted] Pesan rujukan (opsional)
+ * @param {object} [options={}] Opsi tambahan
+ */
+export const sendVoiceNote = async (sock, jid, audio, quoted, options = {}) => {
+    const audioPayload = Buffer.isBuffer(audio) ? audio : (typeof audio === 'string' ? { url: audio } : audio);
+
+    let waveform = options.waveform;
+    if (!waveform && Buffer.isBuffer(audioPayload)) {
+        try {
+            waveform = await getAudioWaveform(audioPayload, sock.logger);
+        } catch {
+            // Fallback default waveform jika decoder tidak tersedia
+            waveform = new Uint8Array([0, 15, 30, 65, 80, 95, 100, 75, 45, 20, 10, 0]);
+        }
+    } else if (!waveform) {
+        waveform = new Uint8Array([0, 15, 30, 65, 80, 95, 100, 75, 45, 20, 10, 0]);
+    }
+
+    return await sock.sendMessage(jid, {
+        audio: audioPayload,
+        mimetype: options.mimetype || 'audio/ogg; codecs=opus',
+        ptt: true,
+        waveform: waveform,
+        ...options
+    }, { quoted });
+};
+
+/**
+ * Mengirim stiker WhatsApp dari media WebP atau buffer gambar/video.
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {Buffer|{ url: string }|string} sticker Buffer sticker atau URL
+ * @param {any} [quoted] Pesan rujukan
+ * @param {object} [options={}] Opsi tambahan
+ */
+export const sendImageAsSticker = async (sock, jid, sticker, quoted, options = {}) => {
+    const stickerPayload = Buffer.isBuffer(sticker) ? sticker : (typeof sticker === 'string' ? { url: sticker } : sticker);
+
+    return await sock.sendMessage(jid, {
+        sticker: stickerPayload,
+        mimetype: 'image/webp',
+        ...options
+    }, { quoted });
+};
+
+/**
+ * Mengirim gambar atau video dengan opsi kualitas HD resmi.
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {{ image?: any, video?: any, caption?: string }} mediaContent Konten media
+ * @param {object} [options={}] Opsi pengiriman
+ */
+export const sendHDMedia = async (sock, jid, mediaContent, options = {}) => {
+    return await sock.sendMessage(jid, {
+        ...mediaContent,
+        viewOnce: false
+    }, {
+        ...options
+    });
+};

package/src/Lyxe/radar.js

@@ -0,0 +1,95 @@
+import { EventEmitter } from 'events';
+
+/**
+ * WhatsApp Intelligence & Presence Radar.
+ * Memantau aktivitas Online/Offline nomor target detik demi detik tanpa perlu chat.
+ */
+export class PresenceRadar extends EventEmitter {
+    constructor(sock) {
+        super();
+        this.sock = sock;
+        this.targets = new Map(); // jid -> { online: boolean, lastSeen: number, history: [] }
+        this.bindEvents();
+    }
+
+    bindEvents() {
+        if (!this.sock) return;
+
+        this.sock.ev.on('presence.update', ({ id, presences }) => {
+            const jid = id;
+            if (!this.targets.has(jid) && !Object.keys(presences || {}).some(k => this.targets.has(k))) {
+                return;
+            }
+
+            for (const [userJid, presence] of Object.entries(presences || {})) {
+                const targetKey = this.targets.has(userJid) ? userJid : jid;
+                const info = this.targets.get(targetKey);
+                if (!info) continue;
+
+                const isAvailable = presence.lastKnownPresence === 'available' || presence.lastKnownPresence === 'composing';
+                const now = Date.now();
+
+                if (isAvailable && !info.online) {
+                    info.online = true;
+                    info.onlineSince = now;
+                    const eventData = { jid: targetKey, status: 'online', time: now };
+                    info.history.push(eventData);
+                    this.emit('presence', eventData);
+                } else if (!isAvailable && info.online) {
+                    const durationMs = now - (info.onlineSince || now);
+                    info.online = false;
+                    info.lastSeen = now;
+                    const eventData = {
+                        jid: targetKey,
+                        status: 'offline',
+                        time: now,
+                        durationMs,
+                        durationSec: Math.round(durationMs / 1000)
+                    };
+                    info.history.push(eventData);
+                    this.emit('presence', eventData);
+                }
+            }
+        });
+    }
+
+    /**
+     * Daftarkan nomor target untuk mulai dipantau status onlinenya secara diam-diam.
+     * @param {string} jid JID target (misal: 628123456789@s.whatsapp.net)
+     * @param {Function} [callback] Callback saat target online/offline
+     */
+    async track(jid, callback) {
+        const formatted = jid.includes('@') ? jid : `${jid.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+        if (!this.targets.has(formatted)) {
+            this.targets.set(formatted, {
+                online: false,
+                onlineSince: 0,
+                lastSeen: 0,
+                history: []
+            });
+        }
+
+        if (typeof callback === 'function') {
+            this.on('presence', (ev) => {
+                if (ev.jid === formatted) callback(ev);
+            });
+        }
+
+        try {
+            await this.sock.presenceSubscribe(formatted);
+        } catch {}
+
+        return formatted;
+    }
+
+    getHistory(jid) {
+        const formatted = jid.includes('@') ? jid : `${jid.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+        return this.targets.get(formatted)?.history || [];
+    }
+
+    getStatus(jid) {
+        const formatted = jid.includes('@') ? jid : `${jid.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+        const item = this.targets.get(formatted);
+        return item ? { online: item.online, lastSeen: item.lastSeen } : null;
+    }
+}

package/src/Lyxe/session-manager.js

@@ -0,0 +1,111 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Manajer sesi multi-nomor terpadu untuk Lyxe Baileys.
+ * Memudahkan menjalankan beberapa bot WhatsApp dalam satu proses.
+ */
+export class LyxeSessionManager extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.sessions = new Map();
+        this.baseConfig = options.baseConfig || {};
+        this.createSocketFn = options.createSocketFn || null;
+    }
+
+    /**
+     * Daftarkan fungsi pembuat socket jika belum disetel di constructor.
+     * @param {Function} fn Fungsi makeWASocket
+     */
+    setSocketFactory(fn) {
+        this.createSocketFn = fn;
+    }
+
+    /**
+     * Menambahkan atau menginisialisasi sesi baru.
+     * @param {string} sessionId ID unik untuk sesi (misal: 'bot-1', 'cs-admin')
+     * @param {object} [customConfig={}] Konfigurasi khusus untuk sesi ini
+     */
+    async createSession(sessionId, customConfig = {}) {
+        if (this.sessions.has(sessionId)) {
+            return this.sessions.get(sessionId);
+        }
+
+        if (typeof this.createSocketFn !== 'function') {
+            throw new Error('LyxeSessionManager: Socket factory belum disetel. Jalankan manager.setSocketFactory(makeWASocket)');
+        }
+
+        const mergedConfig = {
+            ...this.baseConfig,
+            ...customConfig
+        };
+
+        const sock = this.createSocketFn(mergedConfig);
+        sock.sessionId = sessionId;
+
+        // Forward event ke session manager
+        sock.ev.on('connection.update', (update) => {
+            this.emit('connection.update', { sessionId, update });
+        });
+
+        sock.ev.on('messages.upsert', (upsert) => {
+            this.emit('messages.upsert', { sessionId, upsert, sock });
+        });
+
+        this.sessions.set(sessionId, {
+            id: sessionId,
+            sock: sock,
+            config: mergedConfig,
+            createdAt: new Date()
+        });
+
+        this.emit('session.created', { sessionId, sock });
+        return sock;
+    }
+
+    /**
+     * Mengambil instance socket dari sesi yang sedang aktif.
+     * @param {string} sessionId
+     */
+    getSession(sessionId) {
+        const item = this.sessions.get(sessionId);
+        return item ? item.sock : null;
+    }
+
+    /**
+     * Memeriksa apakah sesi sedang terdaftar.
+     * @param {string} sessionId
+     */
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+
+    /**
+     * Menghapus sesi dan menutup koneksinya.
+     * @param {string} sessionId
+     */
+    async deleteSession(sessionId) {
+        const item = this.sessions.get(sessionId);
+        if (!item) return false;
+
+        try {
+            item.sock?.end?.();
+        } catch {
+            // abaikan
+        }
+
+        this.sessions.delete(sessionId);
+        this.emit('session.deleted', { sessionId });
+        return true;
+    }
+
+    /**
+     * Mengambil daftar seluruh sesi yang aktif beserta statusnya.
+     */
+    listSessions() {
+        return Array.from(this.sessions.values()).map(item => ({
+            id: item.id,
+            createdAt: item.createdAt,
+            hasSocket: !!item.sock
+        }));
+    }
+}

package/src/Lyxe/status-tools.js

@@ -0,0 +1,75 @@
+import { delay } from '../Utils/generics.js';
+
+/**
+ * Membaca status/story WhatsApp dengan jeda alami (Auto Read Story).
+ * @param {any} sock Socket Baileys
+ * @param {any} statusMessage Objek pesan status atau key status
+ * @param {number} [delayMs=1500] Jeda sebelum menandai dibaca (ms)
+ */
+export const readStatus = async (sock, statusMessage, delayMs = 1500) => {
+    if (delayMs > 0) {
+        await delay(delayMs);
+    }
+    const key = statusMessage?.key || statusMessage;
+    if (!key) throw new Error('readStatus: key status tidak valid');
+    return await sock.readMessages([key]);
+};
+
+/**
+ * Memberi reaksi emoji ke status WhatsApp pengguna.
+ * @param {any} sock Socket Baileys
+ * @param {any} statusMessageOrKey Pesan status atau key status
+ * @param {string} [emoji='❤️'] Emoji reaksi
+ */
+export const reactStatus = async (sock, statusMessageOrKey, emoji = '❤️') => {
+    const key = statusMessageOrKey?.key || statusMessageOrKey;
+    if (!key) throw new Error('reactStatus: key status tidak valid');
+
+    const participant = key.participant || key.remoteJid;
+    return await sock.sendMessage('status@broadcast', {
+        react: {
+            text: emoji,
+            key: key
+        }
+    }, {
+        statusJidList: [participant]
+    });
+};
+
+/**
+ * Membuat status WhatsApp baru dengan men-tag/mention nomor tertentu.
+ * @param {any} sock Socket Baileys
+ * @param {string|object} content Teks status atau objek pesan media
+ * @param {string[]|string} targetJids Daftar JID kontak yang di-mention
+ * @param {object} [options={}] Opsi tambahan sendMessage
+ */
+export const sendStatusMention = async (sock, content, targetJids = [], options = {}) => {
+    const msg = typeof content === 'string' ? { text: content } : content;
+    const jidList = Array.isArray(targetJids) ? targetJids : [targetJids];
+
+    return await sock.sendMessage('status@broadcast', msg, {
+        statusJidList: jidList,
+        ...options
+    });
+};
+
+/**
+ * Mengirim status rekaman suara (Voice Note Status) ke status WhatsApp.
+ * @param {any} sock Socket Baileys
+ * @param {Buffer|{ url: string }} audio Buffer audio atau URL
+ * @param {object} [options={}] Opsi (backgroundColor, statusJidList, waveform)
+ */
+export const sendVoiceStatus = async (sock, audio, options = {}) => {
+    const audioPayload = Buffer.isBuffer(audio) ? audio : (typeof audio === 'string' ? { url: audio } : audio);
+
+    return await sock.sendMessage('status@broadcast', {
+        audio: audioPayload,
+        mimetype: 'audio/mp4',
+        ptt: true,
+        backgroundColor: options.backgroundColor || '#7F5AF0',
+        waveform: options.waveform || new Uint8Array([0, 10, 25, 45, 70, 90, 100, 80, 50, 30, 10, 0]),
+        ...options
+    }, {
+        statusJidList: options.statusJidList || []
+    });
+};