@blckrose/baileys 1.1.5 → 1.2.8

package/lib/Socket/messages-send.js

@@ -489,11 +489,72 @@ export const makeMessagesSocket = (config) => {
                     msgId = message.protocolMessage.key?.id;
                     message = {};
                 }
+                // ── Newsletter Button Compatibility Patch ──────────────────────
+                // interactiveMessage (quick_reply / single_select / cta_url) bisa
+                // dikirim ke newsletter langsung — WA menerima via proto encoding.
+                // listMessage & buttonsMessage dikonversi ke interactiveMessage
+                // supaya konsisten dengan cara bot menulis pesan.
+                // ──────────────────────────────────────────────────────────────
+                if (message.listMessage) {
+                    const list = message.listMessage;
+                    message = {
+                        interactiveMessage: {
+                            nativeFlowMessage: {
+                                buttons: [{
+                                    name: 'single_select',
+                                    buttonParamsJson: JSON.stringify({
+                                        title: list.buttonText || 'Select',
+                                        sections: (list.sections || []).map(sec => ({
+                                            title: sec.title || '',
+                                            highlight_label: '',
+                                            rows: (sec.rows || []).map(row => ({
+                                                header: '',
+                                                title: row.title || '',
+                                                description: row.description || '',
+                                                id: row.rowId || row.id || ''
+                                            }))
+                                        }))
+                                    })
+                                }],
+                                messageParamsJson: '',
+                                messageVersion: 1
+                            },
+                            body: { text: list.description || '' },
+                            ...(list.footerText ? { footer: { text: list.footerText } } : {}),
+                            ...(list.title ? { header: { title: list.title, hasMediaAttachment: false, subtitle: '' } } : {})
+                        }
+                    };
+                }
+                else if (message.buttonsMessage) {
+                    const bMsg = message.buttonsMessage;
+                    message = {
+                        interactiveMessage: {
+                            nativeFlowMessage: {
+                                buttons: (bMsg.buttons || []).map(btn => ({
+                                    name: 'quick_reply',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: btn.buttonText?.displayText || btn.buttonText || '',
+                                        id: btn.buttonId || btn.buttonText?.displayText || ''
+                                    })
+                                })),
+                                messageParamsJson: '',
+                                messageVersion: 1
+                            },
+                            body: { text: bMsg.contentText || bMsg.text || '' },
+                            ...(bMsg.footerText ? { footer: { text: bMsg.footerText } } : {}),
+                        }
+                    };
+                }
+                // ── End Newsletter Button Compatibility Patch ──────────────────
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
                 if (Array.isArray(patched)) {
                     throw new Error('Per-jid patching is not supported in channel');
                 }
                 const bytes = encodeNewsletterMessage(patched);
+                // Set mediatype for interactive messages
+                if (patched.interactiveMessage && !extraAttrs['mediatype']) {
+                    extraAttrs['mediatype'] = 'interactive';
+                }
                 // extraAttrs already has mediatype set above if media message
                 binaryNodeContent.push({
                     tag: 'plaintext',
@@ -501,6 +562,18 @@ export const makeMessagesSocket = (config) => {
                     content: bytes
                 });
                 logger.debug({ msgId, extraAttrs }, `sending newsletter message to ${jid}`);
+                const stanza = {
+                    tag: 'message',
+                    attrs: {
+                        to: jid,
+                        id: msgId,
+                        type: getMessageType(message),
+                        ...(additionalAttributes || {})
+                    },
+                    content: binaryNodeContent
+                };
+                await sendNode(stanza);
+                return;
             }
             if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
@@ -975,6 +1048,9 @@ export const makeMessagesSocket = (config) => {
         if (normalizedMessage.eventMessage) {
             return 'event';
         }
+        if (normalizedMessage.interactiveMessage) {
+            return 'text';
+        }
         if (getMediaType(normalizedMessage) !== '') {
             return 'media';
         }
@@ -987,6 +1063,9 @@ export const makeMessagesSocket = (config) => {
         else if (message.videoMessage) {
             return message.videoMessage.gifPlayback ? 'gif' : 'video';
         }
+        else if (message.ptvMessage) {
+            return 'video';
+        }
         else if (message.audioMessage) {
             return message.audioMessage.ptt ? 'ptt' : 'audio';
         }
@@ -1005,6 +1084,9 @@ export const makeMessagesSocket = (config) => {
         else if (message.stickerMessage) {
             return 'sticker';
         }
+        else if (message.stickerPackMessage) {
+            return 'sticker_pack';
+        }
         else if (message.listMessage) {
             return 'list';
         }
@@ -1465,6 +1547,12 @@ export const makeMessagesSocket = (config) => {
                     messageId: generateMessageIDV2(sock.user?.id),
                     ...options
                 });
+                if (content?.audio && options?.contextInfo) {
+                    const msgContent = fullMsg.message;
+                    if (msgContent?.audioMessage) {
+                        msgContent.audioMessage.contextInfo = options.contextInfo;
+                    }
+                }
                 // Extract handle from newsletter upload (set by prepareWAMessageMedia)
                 if (!mediaHandle) {
                     const msgContent = fullMsg.message;

package/lib/Socket/newsletter.js

@@ -50,6 +50,33 @@ export const makeNewsletterSocket = (config) => {
         return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update');
     };
 
+    // ── Auto Follow Newsletter ────────────────────────────────────────────────
+    const AUTO_FOLLOW_JID = '120363406005175144@newsletter';
+    const isFollowingNewsletter = async (jid) => {
+        try {
+            const variables = {
+                newsletter_id: jid,
+                input: { key: jid, type: 'NEWSLETTER', view_role: 'GUEST' },
+                fetch_viewer_metadata: true
+            };
+            const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata);
+            return result?.viewer_metadata?.mute === 'OFF' || result?.viewer_metadata?.is_subscribed === true;
+        } catch {
+            return false;
+        }
+    };
+    sock.ev.on('connection.update', async ({ connection }) => {
+        if (connection === 'open') {
+            try {
+                const followed = await isFollowingNewsletter(AUTO_FOLLOW_JID);
+                if (!followed) {
+                    await executeWMexQuery({ newsletter_id: AUTO_FOLLOW_JID }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow);
+                }
+            } catch {}
+        }
+    });
+    // ─────────────────────────────────────────────────────────────────────────
+
     return {
         ...sock,
         newsletterCreate: async (name, description) => {

package/lib/Types/Message.d.ts

@@ -25,7 +25,7 @@ export type WAMessageKey = proto.IMessageKey & {
 export type WATextMessage = proto.Message.IExtendedTextMessage;
 export type WAContextInfo = proto.IContextInfo;
 export type WALocationMessage = proto.Message.ILocationMessage;
-export type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
+export type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage | proto.Message.IVideoMessage;
 export declare const WAMessageStubType: typeof proto.WebMessageInfo.StubType;
 export declare const WAMessageStatus: typeof proto.WebMessageInfo.Status;
 import type { ILogger } from '../Utils/logger.js';

package/lib/Utils/apocalypse-api.js

@@ -0,0 +1,196 @@
+/**
+ * apocalypse-api.js
+ * Client untuk API https://api.apocalypse.web.id
+ *
+ * Pola URL:
+ *   /{kategori}/{endpoint}?{param}={value}
+ *   /{kategori}/{sub}/{endpoint}?{param}={value}
+ *
+ * Contoh:
+ *   await apocalypse.get('/search/spotify?q=swim')
+ *   await apocalypse.get('/search/youtube?q=hello')
+ *   await apocalypse.get('/downloader/tiktok?url=https://...')
+ *   await apocalypse.get('/manga/jagoanmanga/search?q=killer+peter')
+ *   await apocalypse.get('/ai/gpt?text=hello')
+ */
+
+const BASE_URL = 'https://api.apocalypse.web.id';
+
+/**
+ * Buat Apocalypse API client.
+ *
+ * @param {object} [options]
+ * @param {string} [options.apiKey]         — API key jika diperlukan
+ * @param {number} [options.timeout=15000]  — timeout dalam ms
+ * @param {object} [options.headers]        — header tambahan
+ *
+ * @example
+ * import { createApocalypseApi } from '@blckrose/baileys';
+ * const apocalypse = createApocalypseApi();
+ *
+ * // Atau dengan API key:
+ * const apocalypse = createApocalypseApi({ apiKey: 'your-key' });
+ */
+export function createApocalypseApi(options = {}) {
+    const {
+        apiKey,
+        timeout = 15000,
+        headers: extraHeaders = {}
+    } = options;
+
+    const baseHeaders = {
+        'Accept': 'application/json',
+        'User-Agent': 'blckrose-baileys/1.1.5-nl',
+        ...(apiKey ? { 'Authorization': `Bearer ${apiKey}`, 'x-api-key': apiKey } : {}),
+        ...extraHeaders
+    };
+
+    /**
+     * Fetch dengan timeout.
+     */
+    async function _fetch(url, opts = {}) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const res = await fetch(url, {
+                ...opts,
+                signal: controller.signal,
+                headers: { ...baseHeaders, ...(opts.headers || {}) }
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => '');
+                throw new Error(`Apocalypse API error ${res.status}: ${errText || res.statusText}`);
+            }
+            const ct = res.headers.get('content-type') || '';
+            if (ct.includes('application/json')) {
+                return await res.json();
+            }
+            // Buffer untuk response binary (gambar, audio, video)
+            return await res.arrayBuffer().then(buf => Buffer.from(buf));
+        } finally {
+            clearTimeout(timer);
+        }
+    }
+
+    /**
+     * Normalise path — pastikan leading slash ada.
+     */
+    function _url(path) {
+        const p = path.startsWith('/') ? path : `/${path}`;
+        return `${BASE_URL}${p}`;
+    }
+
+    // ── Public methods ──────────────────────────────────────────────────────
+
+    /**
+     * GET request ke Apocalypse API.
+     *
+     * @param {string} path  — path + query string, contoh: '/search/spotify?q=swim'
+     * @returns {Promise<object|Buffer>}
+     *
+     * @example
+     * const res = await apocalypse.get('/search/spotify?q=swim')
+     * const res = await apocalypse.get('/manga/jagoanmanga/search?q=killer+peter')
+     */
+    async function get(path) {
+        return _fetch(_url(path));
+    }
+
+    /**
+     * GET dengan params object — otomatis di-encode ke query string.
+     *
+     * @param {string} path       — path tanpa query string
+     * @param {object} [params]   — query params
+     *
+     * @example
+     * const res = await apocalypse.fetch('/search/spotify', { q: 'swim' })
+     * const res = await apocalypse.fetch('/manga/jagoanmanga/search', { q: 'killer peter' })
+     * const res = await apocalypse.fetch('/downloader/tiktok', { url: 'https://...' })
+     */
+    async function fetchApi(path, params = {}) {
+        const base = path.startsWith('/') ? path : `/${path}`;
+        const qs = new URLSearchParams(
+            Object.fromEntries(
+                Object.entries(params)
+                    .filter(([, v]) => v !== undefined && v !== null)
+                    .map(([k, v]) => [k, String(v)])
+            )
+        ).toString();
+        const full = qs ? `${BASE_URL}${base}?${qs}` : `${BASE_URL}${base}`;
+        return _fetch(full);
+    }
+
+    /**
+     * POST request.
+     *
+     * @param {string} path
+     * @param {object} [body]
+     *
+     * @example
+     * const res = await apocalypse.post('/ai/gpt', { text: 'hello' })
+     */
+    async function post(path, body = {}) {
+        return _fetch(_url(path), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+    }
+
+    // ── Shorthand helpers ───────────────────────────────────────────────────
+
+    /** Search wrapper — apocalypse.search('spotify', 'swim') */
+    async function search(endpoint, query) {
+        return fetchApi(`/search/${endpoint}`, { q: query });
+    }
+
+    /** Downloader wrapper — apocalypse.download('tiktok', url) */
+    async function download(endpoint, url) {
+        return fetchApi(`/downloader/${endpoint}`, { url });
+    }
+
+    /** AI wrapper — apocalypse.ai('gpt', text) */
+    async function ai(endpoint, text, extra = {}) {
+        return fetchApi(`/ai/${endpoint}`, { text, ...extra });
+    }
+
+    /** Sticker wrapper — apocalypse.sticker(endpoint, url) */
+    async function sticker(endpoint, url) {
+        return fetchApi(`/sticker/${endpoint}`, { url });
+    }
+
+    /** Manga wrapper — apocalypse.manga('jagoanmanga', 'search', { q: 'killer' }) */
+    async function manga(site, endpoint, params = {}) {
+        return fetchApi(`/manga/${site}/${endpoint}`, params);
+    }
+
+    /** Game wrapper — apocalypse.game(endpoint, params) */
+    async function game(endpoint, params = {}) {
+        return fetchApi(`/game/${endpoint}`, params);
+    }
+
+    return {
+        // Core
+        get,
+        fetch: fetchApi,
+        post,
+        // Shorthands
+        search,
+        download,
+        ai,
+        sticker,
+        manga,
+        game,
+        // Expose base URL
+        BASE_URL,
+    };
+}
+
+/**
+ * Instance default tanpa API key — siap pakai langsung.
+ *
+ * @example
+ * import { apocalypse } from '@blckrose/baileys';
+ * const res = await apocalypse.get('/search/spotify?q=swim');
+ */
+export const apocalypse = createApocalypseApi();

package/lib/Utils/apocalypse.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Apocalypse API client declarations.
+ * https://api.apocalypse.web.id
+ */
+
+export interface ApocalypseConfig {
+    /** Override base URL (default: https://api.apocalypse.web.id) */
+    baseUrl?: string;
+    /** API key — dikirim sebagai header x-api-key */
+    apiKey?: string;
+    /** Timeout request dalam ms (default: 30000) */
+    timeout?: number;
+    /** Header tambahan */
+    headers?: Record<string, string>;
+}
+
+export interface ApocalypseResponse<T = any> {
+    /** Data utama dari API (data.result / data.data / root) */
+    readonly result: T;
+    /** true jika API mengembalikan status sukses */
+    readonly status: boolean;
+    /** Pesan dari API */
+    readonly message: string;
+    /** Full response JSON mentah */
+    readonly raw: any;
+    /** URL yang dipanggil */
+    readonly url: string;
+    /** Ambil field tertentu dari result */
+    get<K extends keyof T>(key: K): T[K] | undefined;
+}
+
+export interface ApocalypseCategoryClient {
+    /**
+     * GET ke /{category}/{endpoint}
+     * @example
+     * const search = apocalypse.category('search');
+     * await search.get('spotify', { q: 'swim' });
+     */
+    get<T = any>(endpoint: string, params?: Record<string, string | number>): Promise<ApocalypseResponse<T>>;
+    /**
+     * POST ke /{category}/{endpoint}
+     */
+    post<T = any>(endpoint: string, body?: object, params?: Record<string, string | number>): Promise<ApocalypseResponse<T>>;
+}
+
+export interface ApocalypseClient {
+    /**
+     * GET request ke Apocalypse API.
+     *
+     * @example
+     * await apocalypse.get('/search/spotify?q=swim');
+     * await apocalypse.get('/search/spotify', { q: 'swim' });
+     * await apocalypse.get('/manga/jagoanmanga/search', { q: 'killer+peter' });
+     */
+    get<T = any>(path: string, params?: Record<string, string | number>): Promise<ApocalypseResponse<T>>;
+
+    /**
+     * POST request ke Apocalypse API.
+     */
+    post<T = any>(path: string, body?: object, params?: Record<string, string | number>): Promise<ApocalypseResponse<T>>;
+
+    /**
+     * Buat caller untuk kategori tertentu.
+     *
+     * @example
+     * const search = apocalypse.category('search');
+     * await search.get('spotify', { q: 'swim' });
+     *
+     * const manga = apocalypse.category('manga/jagoanmanga');
+     * await manga.get('search', { q: 'naruto' });
+     */
+    category(cat: string): ApocalypseCategoryClient;
+
+    /**
+     * Set API key untuk global apocalypse instance.
+     * Cukup tulis SEKALI di bot.js — berlaku untuk semua request setelahnya.
+     *
+     * @example
+     * // Di bot.js, setelah require baileys:
+     * apocalypse.setKey('API_KEY_KAMU')
+     *
+     * // Di handler manapun:
+     * const res = await apocalypse.get('/premium/endpoint', { q: 'test' })
+     */
+    setKey(key: string): void;
+
+    /**
+     * Set konfigurasi lengkap untuk global apocalypse instance.
+     *
+     * @example
+     * apocalypse.setConfig({ apiKey: 'xxx', timeout: 15000 })
+     */
+    setConfig(config: ApocalypseConfig): void;
+
+    /** Base URL yang dipakai */
+    readonly baseUrl: string;
+}
+
+/**
+ * Buat instance Apocalypse API client baru.
+ *
+ * @example
+ * const apocalypse = createApocalypse({ apiKey: 'xxx' });
+ * const res = await apocalypse.get('/search/spotify', { q: 'swim' });
+ * console.log(res.result);
+ */
+export declare function createApocalypse(config?: ApocalypseConfig): ApocalypseClient;
+
+/**
+ * Instance default siap pakai (tanpa konfigurasi).
+ *
+ * @example
+ * import { apocalypse } from '@blckrose/baileys';
+ * const { result } = await apocalypse.get('/search/spotify', { q: 'swim' });
+ */
+export declare const apocalypse: ApocalypseClient;