swan-api 1.0.0 → 1.1.0

package/Message.js

@@ -31,7 +31,7 @@ export default class Message {
         const ctx = m.extendedTextMessage?.contextInfo;
         if (ctx?.quotedMessage){
             this.quoted = new Message(socket, {
-                key: {remoteJid: this.fromId, fromMe: ctx.participant === socket.user.id},
+                key: {remoteJid: this.fromId, fromMe: ctx.participant === socket.userId},
                 message: ctx.quotedMessage
             });
         }
@@ -52,7 +52,7 @@ export default class Message {
 
     // returns the sender's name and phone number
     async getContact() {
-        const jid = this.fromMe ? this.socket.user.id : this.author;
+        const jid = this.fromMe ? this.socket.userId : this.author;
         const number = jid.split('@')[0];
         return {name: this.fromName, number}
     }

package/README.md

@@ -53,7 +53,7 @@ socket.on("newMessage", async (msg) => {
     if (msg.fromMe)
         return;
 
-    console.log(`Message from ${msg.author}: ${msg.text}`);
+    console.log(`New Message from ${msg.fromName}`);
 
     await msg.reply("Processing your message...");
 
@@ -168,13 +168,58 @@ const media = await MessageMedia.fromUrl("https://example.com/image.png");
 
 ---
 
+### Sticker
+Converts an image or video buffer into a WhatsApp-ready sticker (WebP, 512x512, with embedded pack/author metadata).
+
+You normally don't need to call `Sticker` directly — just use `msg.reply(media, {asSticker: true})`, which handles quality adjustment automatically to stay under WhatsApp's size limit. `Sticker` is exported in case you want to generate the WebP buffer yourself.
+
+#### Options
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `stickerAuthor` | `string` | `""` | Sticker pack publisher name. |
+| `stickerPack` | `string` | `""` | Sticker pack name. |
+| `stickerType` | `string` | `"default"` | Resize/crop mode. See table below. |
+| `stickerQuality` | `number` | `80` | WebP encoding quality (0-100). |
+
+#### Sticker types
+| Type | Behavior |
+| ---- | -------- |
+| `default` | Stretches the image to fill 512x512, ignoring original proportions. |
+| `full` | Keeps original proportions, padding the rest with transparency. |
+| `crop` | Keeps original proportions, cropping the excess to fill 512x512. |
+| `circle` | Same as `crop`, masked into a circle. |
+| `rounded` | Same as `crop`, masked with rounded corners. |
+
+Videos are automatically converted to animated stickers.
+
+#### Usage
+```javascript
+import { Socket, Sticker } from "swan-api";
+const socket = new Socket();
+
+socket.on("newMessage", async (msg) => {
+    const media = await msg.downloadMedia();
+    if (!media)
+        return;
+
+    // send directly as a sticker
+    await msg.reply(media, {
+        asSticker: true,
+        stickerPack: "Bot Pack",
+        stickerAuthor: "Bot"
+    });
+});
+```
+---
+
 ## Exports
 
 ```javascript
 import {  
     Socket,
     Message,
-    MessageMedia
+    MessageMedia,
+    Sticker
 } from "swan-api";
 ```
 

package/Socket.js

@@ -3,20 +3,45 @@ import makeWASocket, { useMultiFileAuthState, fetchLatestBaileysVersion, Disconn
 import P from 'pino'
 import qrcode from 'qrcode-terminal'
 import { EventEmitter } from "node:events";
-import { Sticker } from 'wa-sticker-formatter'
 
+import fs from "node:fs/promises";
+
+
+import Sticker from './Sticker.js'
 import Message from './Message.js';
 import MessageMedia from './MessageMedia.js';
 
 //Wrapper Class For Baileys Socket
 export default class Socket extends EventEmitter {
-    // creates a socket instance
-    constructor() {
+    constructor(){
         super();
-        this.connect();
+        this.muteSessionErrors()
+        this.connect()
+    }
+
+    // hide internal session errors that does not affect the use
+    muteSessionErrors(){
+        const oldLog = console.log;
+        console.log = (...args) => {
+            if (String(args[0]).includes("Closing session"))
+                return;
+
+            oldLog(...args);
+        };
+
+        const oldError = console.error;
+        console.error = (...args) => {
+            if (
+                String(args[0]).includes("Failed to decrypt") ||
+                String(args[0]).includes("Session error")
+            )
+                return;
+
+            oldError(...args);
+        };
     }
 
-    // tries to authenticate and bind default events
+    // creates a Socket instance and tries to authenticate
     async connect() {
         await this.authenticate();
         this.bindEvents();
@@ -26,16 +51,21 @@ export default class Socket extends EventEmitter {
     async authenticate(){
         const { state, saveCreds } = await useMultiFileAuthState('auth')
         const { version } = await fetchLatestBaileysVersion()
+        const logger = P({level: 'silent'})
 
-        this.socket = makeWASocket({version, auth: state, logger: P({level: 'silent'})});
-        this.user = this.socket.user;
+        this.socket = makeWASocket({version, auth: state, logger});
         this.socket.ev.on('creds.update', saveCreds)
     }
 
     //bind events from baileys to default treatment functions
     bindEvents(){
+        let socketReady = false
+
         //each new message emits a 'newMessage' event and a 'Message' object
         this.socket.ev.on('messages.upsert', ({messages}) => {
+            if (!socketReady)
+                return;
+
             for (const msg of messages){
                 if (!msg.message)
                     continue;
@@ -45,7 +75,7 @@ export default class Socket extends EventEmitter {
         
         //emits 'ready' when opens connection
         //on connnection lost, tries to reconnect
-        this.socket.ev.on('connection.update', (update) => {
+        this.socket.ev.on('connection.update', async (update) => {
             const { connection, lastDisconnect, qr } = update;
             if (qr)
                 qrcode.generate(qr, {small: true})
@@ -54,9 +84,12 @@ export default class Socket extends EventEmitter {
                 const shouldReconnect = lastDisconnect?.error?.output?.statusCode
                                                     !== DisconnectReason.loggedOut;
                 if (shouldReconnect)
-                    this.connect();
-            } else if (connection == 'open')
+                    await this.connect()
+            } else if (connection == 'open'){
+                socketReady = true
+                this.userId = this.socket.user.id;
                 this.emit('ready');
+            }
         });
     }
 
@@ -77,32 +110,26 @@ export default class Socket extends EventEmitter {
         
         // parse media for sticker creation
         if (opts.asSticker){
-            const isVideo = mimetype?.startsWith('video') || mimetype === 'image/gif'
-            // video proportion must be 'full' to not get corrupted frames
-            if (isVideo)
-                opts.stickerProportion = 'full'
+            // WhatsApp limits: 100KB for static stickers, 500KB for animated ones
+            const isAnimated = mimetype.startsWith("video/");
+            const maxBytes = (isAnimated ? 500 : 100) * 1024;
 
             // tries to create the sticker at the highest quality,
             // if the resulting file exceeds WhatsApp's 1MB limit
             // the quality is reduced by 10% and retried
             // throws an exception if quality goes below 0%
-            let final_quality = 1;
-            while (final_quality >= 0) {
-                const sticker = new Sticker(buffer, {
-                    pack: opts.stickerName,
-                    author: opts.stickerAuthor,
-                    type: opts.stickerProportion,
-                    quality: final_quality,
-                });
-
-                const webp = await sticker.toBuffer();
-                const size = (webp.length/1024)/1024;
-                if (size >= 1)
-                    final_quality -= 0.1;
+            let final_quality = 100;
+            while (final_quality > 0) {
+                const webp = await Sticker(buffer, {...opts,
+                                                stickerQuality : final_quality})
+
+                if (webp.length > maxBytes)
+                    final_quality -= 10;
                 else
                     return await this.socket.sendMessage(jid, {sticker: webp}, opts)
             }
 
+            throw new Error(`SWAN send(): could not compress sticker below ${maxBytes / 1024}KB`);
         }
 
         //send regular files

package/Sticker.js

@@ -0,0 +1,125 @@
+import sharp from "sharp";
+import ffmpegPath from "ffmpeg-static";
+import { execa } from "execa";
+import { fileTypeFromBuffer } from "file-type";
+
+export default async function Sticker(buffer, opts = {}) {
+    const author = opts.stickerAuthor ? opts.stickerAuthor : "";
+    const pack = opts.stickerPack ? opts.stickerPack : "";
+    const type = opts.stickerType ? opts.stickerType : "fill";
+    const quality = opts.stickerQuality ? opts.stickerQuality : 80;
+
+    const info = await fileTypeFromBuffer(buffer);
+    if (!info)
+        throw Error("Unknown file type");
+
+    if (info.mime.startsWith("video/"))
+        buffer = await convertVideo(buffer);
+    else if (!info.mime.startsWith("image/"))
+        throw Error(`Unsupported media type: ${info.mime}`);
+
+    const fit = type === "full" ? "contain" :
+                type === "fill" ? "fill" : "cover"; // crop, circle, rounded
+
+    let image = sharp(buffer).resize(512, 512, {fit,
+                    background: { r: 0, g: 0, b: 0, alpha: 0 }}).ensureAlpha();
+
+    if (type === "circle")
+        image = image.composite([{
+            input: Buffer.from(`<svg width="512" height="512">
+                        <circle cx="256" cy="256" r="256" fill="white"/></svg>`),
+            blend: "dest-in"
+        }]);
+
+    if (type === "rounded")
+        image = image.composite([{
+            blend: "dest-in",
+            input: Buffer.from(`<svg width="512" height="512">
+                                    <rect x="0" y="0" width="512" height="512"
+                                        rx="64" ry="64" fill="white"/></svg>`),
+        }]);
+
+    const webp = await image.webp({ quality }).toBuffer();    
+    return addExif(webp, author, pack)
+}
+
+// for animated stickers
+async function convertVideo(buffer) {
+    const { stdout } = await execa(ffmpegPath, [
+        "-i", "pipe:0", "-vcodec", "libwebp", "-vf",
+        "scale=512:512:force_original_aspect_ratio=decrease",
+        "-loop", "0", "-an", "-f", "webp", "pipe:1"
+    ], { input: buffer, encoding: null });
+
+    return stdout;
+}
+
+// Add metadata
+function addExif(webp, author, pack) {
+    const json = Buffer.from(JSON.stringify({
+        "sticker-pack-id": "com.swan.sticker",
+        "sticker-pack-name": pack,
+        "sticker-pack-publisher": author,
+        "emojis": []
+    }));
+
+    const tiff = Buffer.alloc(22 + json.length);
+    tiff.write("II", 0);
+    tiff.writeUInt16LE(42, 2);
+    tiff.writeUInt32LE(8, 4);
+    tiff.writeUInt16LE(1, 8);
+    tiff.writeUInt16LE(0x5741, 10);
+    tiff.writeUInt16LE(7, 12);
+    tiff.writeUInt32LE(json.length, 14);
+    tiff.writeUInt32LE(22, 18);
+    json.copy(tiff, 22);
+
+    let exif = Buffer.concat([
+        Buffer.from("EXIF"),
+        Buffer.alloc(4),
+        tiff
+    ]);
+    exif.writeUInt32LE(tiff.length, 4);
+    if (exif.length % 2)
+        exif = Buffer.concat([exif, Buffer.from([0])]);
+
+    // EXIF flag in VP8X
+    let body = Buffer.from(webp.subarray(12));
+    body = ensureVP8X(body);
+    if (body.subarray(0, 4).toString("ascii") === "VP8X")
+        body[8] |= 0x08;
+
+    const riffSize = Buffer.alloc(4);
+    riffSize.writeUInt32LE(4 + body.length + exif.length); // +4 = "WEBP"
+
+    return Buffer.concat([
+        webp.subarray(0, 4),   // "RIFF"
+        riffSize,
+        webp.subarray(8, 12),  // "WEBP"
+        body,                  // image data
+        exif                   // EXIF
+    ]);
+}
+
+// Adds VP8X container if sharp didn't generated it
+function ensureVP8X(body) {
+    const fourcc = body.subarray(0, 4).toString("ascii");
+    if (fourcc === "VP8X") return body;
+    if (fourcc !== "VP8 " && fourcc !== "VP8L") return body;
+
+    const width = 512, height = 512; // always 512x512
+
+    const vp8x = Buffer.alloc(18);
+    vp8x.write("VP8X", 0);
+    vp8x.writeUInt32LE(10, 4); // payload size
+
+    let flags = 0;
+    if (fourcc === "VP8L") flags |= 0x10; // VP8L supports alpha
+    vp8x[8] = flags;
+    // bytes 9-11 (reserved) 0 by alloc
+
+    vp8x.writeUIntLE(width - 1, 12, 3);
+    vp8x.writeUIntLE(height - 1, 15, 3);
+
+    return Buffer.concat([vp8x, body]);
+}

package/index.js

@@ -1,3 +1,4 @@
 export { default as Socket } from './Socket.js';
 export { default as Message } from './Message.js';
 export { default as MessageMedia } from './MessageMedia.js';
+export { default as Sticker } from './Sticker.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swan-api",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Simple WhatsApp API for Node",
   "keywords": [
     "whatsapp",
@@ -30,6 +30,7 @@
     "Socket.js",
     "Message.js",
     "MessageMedia.js",
+    "Sticker.js",
     "README.md",
     "LICENSE"
   ],
@@ -37,11 +38,18 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@whiskeysockets/baileys": "^6.7.18",
-    "axios": "^1.11.0",
-    "pino": "^9.7.0",
-    "mime-types": "^3.0.1",
+    "@whiskeysockets/baileys": "^7.0.0-rc13",
     "qrcode-terminal": "^0.12.0",
-    "wa-sticker-formatter": "^4.4.4"
+    "pino": "^10.3.1",
+    "axios": "^1.18.1",
+    "mime-types": "^3.0.2",
+    "ffmpeg-static": "^5.2.0",
+    "execa": "^9.6.0"
+  },
+  "allowScripts": {
+    "@whiskeysockets/baileys@7.0.0-rc13": true,
+    "protobufjs@7.6.5": true,
+    "sharp@0.30.7": true,
+    "ffmpeg-static@5.3.0": true
   }
 }