jagproject 26.3.22 → 26.3.23

package/lib/Defaults/index.js

@@ -9,7 +9,7 @@ const libsignal_1 = require("../Signal/libsignal");
 const browser_utils_1 = require("../Utils/browser-utils");
 const logger_1 = __importDefault(require("../Utils/logger"));
 const waVer = require("./wileys-version.json");
-exports.version = waVer?.version || [2, 3000, 1035700054];
+exports.version = waVer?.version || [2, 3000, 1036687490];
 exports.UNAUTHORIZED_CODES = [401, 403, 419];
 exports.DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 exports.CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
@@ -85,7 +85,9 @@ exports.MEDIA_PATH_MAP = {
     'product-catalog-image': '/product/image',
     'md-app-state': '',
     'md-msg-hist': '/mms/md-app-state',
-    'biz-cover-photo': '/pps/biz-cover-photo'
+    'biz-cover-photo': '/pps/biz-cover-photo',
+    'sticker-pack': '/mms/sticker',
+    'thumbnail-sticker-pack': '/mms/image'
 };
 exports.MEDIA_HKDF_KEY_MAPPING = {
     audio: 'Audio',
@@ -106,7 +108,9 @@ exports.MEDIA_HKDF_KEY_MAPPING = {
     'product-catalog-image': '',
     'payment-bg-image': 'Payment Background',
     ptv: 'Video',
-    'biz-cover-photo': 'Image'
+    'biz-cover-photo': 'Image',
+    'sticker-pack': 'Sticker Pack',
+    'thumbnail-sticker-pack': 'Image Thumbnail'
 };
 exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
 exports.MIN_PREKEY_COUNT = 5;

package/lib/Defaults/wileys-version.json

@@ -2,7 +2,7 @@
   "version": [
     2,
     3000,
-    1035700054
+    1036687490
   ],
-  "raw": "2.3000.1035700054"
+  "raw": "2.3000.1036687490"
 }

package/lib/Socket/messages-send.js

@@ -634,6 +634,9 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         else if (message.stickerMessage) {
             return 'sticker';
         }
+        else if (message.stickerPackMessage) {
+            return 'sticker_pack';
+        }
         else if (message.listMessage) {
             return 'list';
         }

package/lib/Utils/messages.js

@@ -444,6 +444,354 @@ const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    else if ('stickerPack' in message && !!message.stickerPack) {
+        const { zip } = require('fflate');
+        const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
+        const coverSource = cover || ((stickers[0] && (stickers[0].data || stickers[0].sticker)) || null);
+        if (!Array.isArray(stickers)) {
+            throw new boom_1.Boom('stickerPack.stickers must be an array', { statusCode: 400 });
+        }
+        if (stickers.length > 60) {
+            throw new boom_1.Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+        }
+        if (stickers.length === 0) {
+            throw new boom_1.Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+        }
+        const stickerPackId = packId || (0, generics_1.generateMessageIDV2)();
+        let sharpLib = null;
+        let jimpLib = null;
+        try {
+            sharpLib = require('sharp');
+        }
+        catch (_sharpError) { }
+        try {
+            jimpLib = require('jimp');
+        }
+        catch (_jimpError) { }
+        if (!sharpLib && !jimpLib) {
+            throw new boom_1.Boom('No image processing library available (install sharp or jimp)', { statusCode: 400 });
+        }
+        const isWebPBuffer = (buf) => (buf.length >= 12
+            && buf[0] === 0x52
+            && buf[1] === 0x49
+            && buf[2] === 0x46
+            && buf[3] === 0x46
+            && buf[8] === 0x57
+            && buf[9] === 0x45
+            && buf[10] === 0x42
+            && buf[11] === 0x50);
+        const isAnimatedWebP = (buf) => {
+            if (!isWebPBuffer(buf)) {
+                return false;
+            }
+            let offset = 12;
+            while (offset < buf.length - 8) {
+                const fourCC = buf.toString('ascii', offset, offset + 4);
+                const chunkSize = buf.readUInt32LE(offset + 4);
+                if (fourCC === 'VP8X') {
+                    const flagsOffset = offset + 8;
+                    if (flagsOffset < buf.length && (buf[flagsOffset] & 0x02)) {
+                        return true;
+                    }
+                }
+                else if (fourCC === 'ANIM' || fourCC === 'ANMF') {
+                    return true;
+                }
+                offset += 8 + chunkSize + (chunkSize % 2);
+            }
+            return false;
+        };
+        const getJimpBuffer = async (image, mime) => {
+            if (typeof image.getBufferAsync === 'function') {
+                return await image.getBufferAsync(mime);
+            }
+            return await new Promise((resolve, reject) => {
+                image.getBuffer(mime, (err, result) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(result);
+                    }
+                });
+            });
+        };
+        const { spawn } = require('child_process');
+        const { promises: fsPromises } = require('fs');
+        const { join } = require('path');
+        const { tmpdir } = require('os');
+        const isPngBuffer = (buf) => (buf.length >= 8
+            && buf[0] === 0x89
+            && buf[1] === 0x50
+            && buf[2] === 0x4e
+            && buf[3] === 0x47);
+        const isJpegBuffer = (buf) => (buf.length >= 3
+            && buf[0] === 0xff
+            && buf[1] === 0xd8
+            && buf[2] === 0xff);
+        const isGifBuffer = (buf) => (buf.length >= 4 && buf.slice(0, 4).toString() === 'GIF8');
+        const isWebmBuffer = (buf) => (buf.length >= 4
+            && buf[0] === 0x1a
+            && buf[1] === 0x45
+            && buf[2] === 0xdf
+            && buf[3] === 0xa3);
+        const isMp4Buffer = (buf) => (buf.length >= 8
+            && buf[4] === 0x66
+            && buf[5] === 0x74
+            && buf[6] === 0x79
+            && buf[7] === 0x70);
+        const looksLikeGzip = (buf) => (buf.length >= 2 && buf[0] === 0x1f && buf[1] === 0x8b);
+        const inferSourceKind = (buffer, source, stickerItem) => {
+            var _c, _d, _e, _f;
+            if (isAnimatedWebP(buffer)) {
+                return 'animated-webp';
+            }
+            if (isWebPBuffer(buffer)) {
+                return 'webp';
+            }
+            if (isPngBuffer(buffer)) {
+                return 'png';
+            }
+            if (isJpegBuffer(buffer)) {
+                return 'jpg';
+            }
+            if (isGifBuffer(buffer)) {
+                return 'gif';
+            }
+            if (isWebmBuffer(buffer)) {
+                return 'webm';
+            }
+            if (isMp4Buffer(buffer)) {
+                return 'mp4';
+            }
+            if (looksLikeGzip(buffer)) {
+                return 'tgs';
+            }
+            const hint = String(((_c = stickerItem === null || stickerItem === void 0 ? void 0 : stickerItem.format) !== null && _c !== void 0 ? _c : ((_d = stickerItem === null || stickerItem === void 0 ? void 0 : stickerItem.mimetype) !== null && _d !== void 0 ? _d : ((_f = (_e = source) === null || _e === void 0 ? void 0 : _e.url) === null || _f === void 0 ? void 0 : _f.toString()))) || '').toLowerCase();
+            if (hint.includes('webm')) {
+                return 'webm';
+            }
+            if (hint.includes('mp4') || hint.includes('mov') || hint.includes('mkv') || hint.includes('avi')) {
+                return 'mp4';
+            }
+            if (hint.includes('gif')) {
+                return 'gif';
+            }
+            if (hint.includes('png')) {
+                return 'png';
+            }
+            if (hint.includes('jpg') || hint.includes('jpeg')) {
+                return 'jpg';
+            }
+            if (hint.includes('tgs') || hint.includes('lottie') || hint.includes('json')) {
+                return 'tgs';
+            }
+            return 'unknown';
+        };
+        const convertStaticToWebp = async (buffer, label) => {
+            if (isWebPBuffer(buffer)) {
+                return buffer;
+            }
+            if (sharpLib) {
+                return await sharpLib(buffer)
+                    .resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+                    .webp({ quality: 80, lossless: false })
+                    .toBuffer();
+            }
+            if (jimpLib) {
+                const JimpCtor = jimpLib.Jimp || jimpLib.default || jimpLib;
+                const image = await JimpCtor.read(buffer);
+                image.contain(512, 512);
+                return await getJimpBuffer(image, 'image/webp');
+            }
+            throw new boom_1.Boom(`No image processing library available for converting ${label} to WebP`, { statusCode: 400 });
+        };
+        const runFfmpegToWebp = async (inputBuffer, inputExt, animated, label) => {
+            const baseName = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            const inputPath = join(tmpdir(), `sticker-pack-${baseName}.${inputExt || 'bin'}`);
+            const outputPath = join(tmpdir(), `sticker-pack-${baseName}.webp`);
+            await fsPromises.writeFile(inputPath, inputBuffer);
+            const args = animated
+                ? [
+                    '-y',
+                    '-i', inputPath,
+                    '-vf', 'fps=12,scale=512:512:force_original_aspect_ratio=decrease:flags=lanczos,pad=512:512:-1:-1:color=0x00000000',
+                    '-loop', '0',
+                    '-an',
+                    '-vsync', '0',
+                    '-s', '512:512',
+                    '-vcodec', 'libwebp_anim',
+                    '-lossless', '0',
+                    '-compression_level', '6',
+                    '-q:v', '55',
+                    outputPath,
+                ]
+                : [
+                    '-y',
+                    '-i', inputPath,
+                    '-vf', 'scale=512:512:force_original_aspect_ratio=decrease:flags=lanczos,pad=512:512:-1:-1:color=0x00000000',
+                    '-frames:v', '1',
+                    '-vcodec', 'libwebp',
+                    '-lossless', '0',
+                    '-compression_level', '6',
+                    '-q:v', '70',
+                    outputPath,
+                ];
+            await new Promise((resolve, reject) => {
+                const ff = spawn('ffmpeg', args);
+                let stderr = '';
+                ff.stderr.on('data', (chunk) => {
+                    stderr += chunk.toString();
+                });
+                ff.on('error', (err) => reject(new boom_1.Boom(`ffmpeg not available for ${label}: ${err.message}`, { statusCode: 400 })));
+                ff.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(new boom_1.Boom(`ffmpeg failed while converting ${label} (code ${code})\n${stderr}`, { statusCode: 400 }));
+                    }
+                });
+            });
+            try {
+                return await fsPromises.readFile(outputPath);
+            }
+            finally {
+                await Promise.allSettled([
+                    fsPromises.unlink(inputPath),
+                    fsPromises.unlink(outputPath)
+                ]);
+            }
+        };
+        const toWebpBuffer = async (buffer, label, source, stickerItem) => {
+            const sourceKind = inferSourceKind(buffer, source, stickerItem);
+            if (sourceKind === 'animated-webp' || sourceKind === 'webp') {
+                return buffer;
+            }
+            if (sourceKind === 'png' || sourceKind === 'jpg') {
+                return await convertStaticToWebp(buffer, label);
+            }
+            if (sourceKind === 'gif' || sourceKind === 'webm' || sourceKind === 'mp4') {
+                return await runFfmpegToWebp(buffer, sourceKind, true, label);
+            }
+            if (sourceKind === 'tgs') {
+                throw new boom_1.Boom(`TGS/Lottie source for ${label} is not supported in this runtime`, { statusCode: 400 });
+            }
+            return await convertStaticToWebp(buffer, label);
+        };
+        const toStaticWebpCoverBuffer = async (buffer, label, source, stickerItem) => {
+            const sourceKind = inferSourceKind(buffer, source, stickerItem);
+            if (sourceKind === 'gif' || sourceKind === 'webm' || sourceKind === 'mp4' || sourceKind === 'animated-webp') {
+                return await runFfmpegToWebp(buffer, sourceKind === 'animated-webp' ? 'webp' : sourceKind, false, label);
+            }
+            return await convertStaticToWebp(buffer, label);
+        };
+        const stickerData = {};
+        const stickerMetadata = await Promise.all(stickers.map(async (stickerItem, index) => {
+            const mediaSource = (stickerItem === null || stickerItem === void 0 ? void 0 : stickerItem.data) || (stickerItem === null || stickerItem === void 0 ? void 0 : stickerItem.sticker);
+            if (!mediaSource) {
+                throw new boom_1.Boom(`Sticker at index ${index} is missing data/sticker`, { statusCode: 400 });
+            }
+            const { stream } = await (0, messages_media_1.getStream)(mediaSource);
+            const buffer = await (0, messages_media_1.toBuffer)(stream);
+            const webpBuffer = await toWebpBuffer(buffer, `sticker at index ${index}`, mediaSource, stickerItem);
+            if (webpBuffer.length > 1024 * 1024) {
+                throw new boom_1.Boom(`Sticker at index ${index} exceeds the 1MB size limit`, { statusCode: 400 });
+            }
+            const hash = (0, crypto_2.sha256)(webpBuffer).toString('base64').replace(/\//g, '-');
+            const fileName = `${hash}.webp`;
+            stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
+            return {
+                fileName,
+                mimetype: 'image/webp',
+                isAnimated: isAnimatedWebP(webpBuffer),
+                emojis: stickerItem.emojis || [],
+                accessibilityLabel: stickerItem.accessibilityLabel || ''
+            };
+        }));
+        const trayIconFileName = `${stickerPackId}.webp`;
+        if (!coverSource) {
+            throw new boom_1.Boom('stickerPack.cover is required when no valid sticker media is available', { statusCode: 400 });
+        }
+        const { stream: coverStream } = await (0, messages_media_1.getStream)(coverSource);
+        const coverBuffer = await (0, messages_media_1.toBuffer)(coverStream);
+        const coverWebpBuffer = await toStaticWebpCoverBuffer(coverBuffer, 'cover', coverSource, stickers[0]);
+        stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
+        const zipBuffer = await new Promise((resolve, reject) => {
+            zip(stickerData, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(Buffer.from(data));
+                }
+            });
+        });
+        const stickerPackUpload = await (0, messages_media_1.encryptedStream)(zipBuffer, 'sticker-pack', {
+            logger: options.logger,
+            opts: options.options
+        });
+        const stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+        m.stickerPackMessage = {
+            name,
+            publisher,
+            stickerPackId,
+            packDescription: description,
+            stickerPackOrigin: WAProto_1.proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+            stickerPackSize: zipBuffer.length,
+            stickers: stickerMetadata,
+            fileSha256: stickerPackUpload.fileSha256,
+            fileEncSha256: stickerPackUpload.fileEncSha256,
+            mediaKey: stickerPackUpload.mediaKey,
+            directPath: stickerPackUploadResult.directPath,
+            fileLength: stickerPackUpload.fileLength,
+            mediaKeyTimestamp: (0, generics_1.unixTimestampSeconds)(),
+            trayIconFileName
+        };
+        try {
+            let thumbnailBuffer;
+            if (sharpLib) {
+                thumbnailBuffer = await sharpLib(coverWebpBuffer).resize(252, 252).jpeg().toBuffer();
+            }
+            else if (jimpLib) {
+                const JimpCtor = jimpLib.Jimp || jimpLib.default || jimpLib;
+                const image = await JimpCtor.read(coverWebpBuffer);
+                thumbnailBuffer = await getJimpBuffer(image.resize({ w: 252, h: 252 }), 'image/jpeg');
+            }
+            if (thumbnailBuffer && thumbnailBuffer.length) {
+                const thumbUpload = await (0, messages_media_1.encryptedStream)(thumbnailBuffer, 'thumbnail-sticker-pack', {
+                    logger: options.logger,
+                    opts: options.options,
+                    mediaKey: stickerPackUpload.mediaKey
+                });
+                const thumbUploadResult = await options.upload(thumbUpload.encWriteStream, {
+                    fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                    mediaType: 'thumbnail-sticker-pack',
+                    timeoutMs: options.mediaUploadTimeoutMs
+                });
+                Object.assign(m.stickerPackMessage, {
+                    thumbnailDirectPath: thumbUploadResult.directPath,
+                    thumbnailSha256: thumbUpload.fileSha256,
+                    thumbnailEncSha256: thumbUpload.fileEncSha256,
+                    thumbnailHeight: 252,
+                    thumbnailWidth: 252,
+                    imageDataHash: (0, crypto_2.sha256)(thumbnailBuffer).toString('base64')
+                });
+            }
+        }
+        catch (error) {
+            var _r, _s;
+            (_s = (_r = options.logger) === null || _r === void 0 ? void 0 : _r.warn) === null || _s === void 0 ? void 0 : _s.call(_r, { err: error }, 'sticker pack thumbnail generation failed');
+        }
+        m.stickerPackMessage.contextInfo = {
+            ...((message.contextInfo) || {}),
+            ...((message.mentions) ? { mentionedJid: message.mentions } : {})
+        };
+    }
     else if ('event' in message) {
         m.messageContextInfo = {
             messageSecret: message.event.messageSecret || (0, crypto_1.randomBytes)(32),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jagproject",
-  "version": "26.03.22",
-   "update": "22 Maret 2026",
+  "version": "26.03.23",
+  "update": "22 Maret 2026",
   "description": "WhatsApp Web API Library",
   "keywords": [
     "jagoan",
@@ -12,7 +12,7 @@
     "automation",
     "multi-device"
   ],
-"homepage": "https://whatsapp.com/channel/0029VanhMDo42DcjiRGJOc2m",
+  "homepage": "https://whatsapp.com/channel/0029VanhMDo42DcjiRGJOc2m",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ChandraGO/jagoans.git"
@@ -65,7 +65,8 @@
     "pino": "^9.6",
     "protobufjs": "^6.11.3",
     "uuid": "^10.0.0",
-    "ws": "^8.13.0"
+    "ws": "^8.13.0",
+    "fflate": "^0.8.2"
   },
   "devDependencies": {
     "@adiwajshing/eslint-config": "github:adiwajshing/eslint-config",

package/readme.md

@@ -68,6 +68,78 @@ yarn add jagproject
 ---
 
 
+# Cara Pakai Cepat
+
+## Instalasi
+
+```bash
+npm install jagproject
+```
+
+## Pemakaian Dasar
+
+```javascript
+const { default: makeWASocket, useMultiFileAuthState } = require('jagproject')
+
+async function startBot() {
+  const { state, saveCreds } = await useMultiFileAuthState('./session')
+
+  const sock = makeWASocket({
+    auth: state,
+    printQRInTerminal: true
+  })
+
+  sock.ev.on('creds.update', saveCreds)
+
+  sock.ev.on('connection.update', ({ connection }) => {
+    if (connection === 'open') {
+      console.log('Bot connected')
+    }
+  })
+}
+
+startBot()
+```
+
+## Kirim Sticker Pack
+
+```javascript
+await sock.sendMessage('6281234567890@s.whatsapp.net', {
+  stickerPack: {
+    name: 'Baileys Wileyss',
+    publisher: 'Project Pemuda',
+    description: 'Sticker pack custom dari Wileyss',
+    cover: { url: './assets/cover.png' },
+    stickers: [
+      { sticker: { url: './assets/sticker-1.webp' }, emojis: ['😀'] },
+      { sticker: { url: './assets/sticker-2.webp' }, emojis: ['🔥'] },
+      { sticker: { url: './assets/sticker-3.png' }, emojis: ['🚀'] }
+    ]
+  }
+})
+```
+
+### Format object `stickerPack`
+
+- `name`: nama pack sticker
+- `publisher`: nama author/publisher
+- `description`: deskripsi pack
+- `cover`: cover/tray icon, bisa file path, buffer, stream, atau URL
+- `stickers`: array isi sticker, minimal 1 maksimal 60
+- `sticker`: media tiap sticker, bisa WebP/PNG/JPG. Jika bukan WebP akan dicoba dikonversi otomatis
+- `emojis`: emoji untuk sticker terkait
+- `accessibilityLabel`: label opsional
+- `packId`: opsional, jika tidak diisi akan dibuat otomatis
+
+### Catatan
+
+- Sangat disarankan install `sharp` agar konversi gambar ke WebP lebih stabil.
+- Jika `sharp` tidak ada, library akan mencoba memakai `jimp`.
+- Ukuran tiap sticker maksimal 1 MB.
+- Jumlah sticker maksimal 60 per pack.
+
+---
+
 # Documentation
 
 - [Connecting Account](#connecting-account) 
@@ -119,6 +191,7 @@ yarn add jagproject
         - [Audio Message](#audio-message)
         - [Image Message](#image-message)
         - [ViewOnce Message](#view-once-message)
+        - [Sticker Pack Message](#kirim-sticker-pack)
 - [Modify Messages](#modify-messages)
     - [Delete Messages (for everyone)](#deleting-messages-for-everyone)
     - [Edit Messages](#editing-messages)
@@ -1873,3 +1946,27 @@ Gunakan secara bertanggung jawab dan hindari aktivitas ilegal atau penyalahgunaa
 
 📘 *Documentation powered by jagoan project*  
 🧑‍💻 **Modified and Presented by Jagoan Project**
+
+<a id="kirim-sticker-pack"></a>
+## Sticker Pack Message
+
+Gunakan field `stickerPack` pada `sendMessage` untuk mengirim satu paket sticker sekaligus.
+
+Catatan penting: `stickerPack` sekarang bisa menerima campuran sticker statis dan video/animated (`webp/png/jpg/jpeg/gif/webm/mp4`) lalu mengonversinya ke WebP otomatis saat proses kirim, selama `ffmpeg` tersedia di server. Format `tgs`/Lottie tetap butuh preview/konverter tambahan di luar runtime ini.
+
+```javascript
+await sock.sendMessage(jid, {
+  stickerPack: {
+    name: 'Nama Pack',
+    publisher: 'Nama Publisher',
+    description: 'Deskripsi singkat',
+    cover: { url: './cover.png' },
+    stickers: [
+      { sticker: { url: './1.webp' }, emojis: ['🙂'] },
+      { sticker: { url: './2.png' }, emojis: ['🎉'] }
+    ]
+  }
+})
+```
+
+`cover` dan setiap item `sticker` menerima format media yang sama seperti pengiriman media biasa: path lokal, URL, Buffer, atau stream.