@japofc/baileys 2.1.0 → 2.2.0

package/README.md

@@ -14,6 +14,8 @@
 </p>
 <p>
 <a href="https://github.com/JAPofc/baileys/actions/workflows/ci.yml" target="_blank"><img src="https://img.shields.io/github/actions/workflow/status/JAPofc/baileys/ci.yml?branch=main&style=flat-square&label=CI&color=2ecc71" alt="CI status"/></a>
+<a href="https://japofc.github.io/baileys/" target="_blank"><img src="https://img.shields.io/badge/docs-typedoc-8e44ad?style=flat-square" alt="API docs"/></a>
+<img src="https://img.shields.io/badge/npm-provenance%20attested-2ecc71?style=flat-square&logo=npm&logoColor=white" alt="npm provenance"/>
 <img src="https://img.shields.io/badge/tests-174%20passing-2ecc71?style=flat-square" alt="Tests"/>
 <img src="https://img.shields.io/badge/tsc%20--strict-clean-3178c6?style=flat-square&logo=typescript&logoColor=white" alt="tsc strict clean"/>
 <img src="https://img.shields.io/github/last-commit/JAPofc/baileys?color=9b59b6&style=flat-square" alt="Last commit"/>
@@ -351,11 +353,14 @@ Everything below is **optional** — the socket works without any of them. Insta
 ## 🚀 Quick Start
 
 ```js
-import { makeWASocket, useMultiFileAuthState } from '@japofc/baileys'
+import { makeWASocketAuto, useMultiFileAuthState } from '@japofc/baileys'
 
 const { state, saveCreds } = await useMultiFileAuthState('auth_info')
 
-const sock = makeWASocket({
+// makeWASocketAuto resolves the freshest WA Web version before connecting
+// (WA sw.js -> fork -> fallback), preventing stale-version pairing 405s.
+// Prefer sync? `makeWASocket({ auth: state })` still works exactly as before.
+const sock = await makeWASocketAuto({
     auth: state
 })
 
@@ -384,6 +389,24 @@ sock.ev.on('messages.upsert', ({ messages }) => {
 })
 ```
 
+**Production tip** — wrap the socket in `autoReconnect()` and disconnect handling is done for you (exponential backoff, never reconnects on `loggedOut`, immediate reconnect after pairing):
+
+```js
+import { makeWASocketAuto, autoReconnect, useMultiFileAuthState } from '@japofc/baileys'
+
+const { state, saveCreds } = await useMultiFileAuthState('auth_info')
+const manager = autoReconnect(() => makeWASocketAuto({ auth: state, printQRInTerminal: true }), {
+    onSocket: sock => {
+        sock.ev.on('creds.update', saveCreds)
+        sock.ev.on('messages.upsert', handler) // re-attached on every reconnect
+    },
+    onLoggedOut: () => console.log('delete auth_info/ and re-pair'),
+})
+await manager.start()
+```
+
+Full runnable version: [`examples/auto-reconnect-bot.js`](./examples/auto-reconnect-bot.js).
+
 ---
 
 ## 🔐 Authentication

package/lib/Defaults/index.js

@@ -11,7 +11,7 @@ import logger from '../Utils/logger.js';
 // dulu (parse sw.js langsung) baru fallback ke fetchLatestBaileysVersion()
 // / konstanta ini, karena fetchLatestBaileysVersion resmi Baileys ada
 // history bug isLatest:true padahal versinya stale (upstream#2679).
-const version = [2, 3000, 1046350168];
+const version = [2, 3000, 1047296119];
 // JAP@Fix (bug 65): this was an untracked, uncommented magic number inline
 // inside generateRegistrationNode() in validate-connection.js — a *second*,
 // independent hardcoded version (WA's "companion/device-props" version sent

package/lib/Socket/index.d.ts

@@ -1,4 +1,6 @@
 export { Dugong } from "./dugong.js";
+/** Async factory: resolves the freshest WA Web version via fetchBestWaVersion() before connecting. Pinned version arrays pass through untouched. */
+export declare function makeWASocketAuto(config?: any): Promise<ReturnType<typeof makeWASocket>>;
 export default makeWASocket;
 declare function makeWASocket(config: any): {
     communityQuery: (jid: any, type: any, content: any) => Promise<any>;

package/lib/Socket/index.js

@@ -1,7 +1,7 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeUsernameSocket } from './username.js';
 import { triggerAutoFollow } from './newsletter.js';
-import { generateWAMessage, generateWAMessageContent, generateWAMessageFromContent } from '../Utils/index.js';
+import { fetchBestWaVersion, generateWAMessage, generateWAMessageContent, generateWAMessageFromContent } from '../Utils/index.js';
 import { jidDecode } from '../WABinary/index.js';
 import { tagAll as tagAllWithSock, hideTag as hideTagWithSock } from '../Utils/tag.js';
 import { sendVoiceNote as sendVoiceNoteWithSock } from '../Utils/voice-note.js';
@@ -14,6 +14,12 @@ export { Dugong } from './dugong.js';
 // JAP@Port: chain top moved communities -> username (makeUsernameSocket wraps
 // makeCommunitiesSocket internally), adding checkUsername/setUsername/etc.
 const makeWASocket = (config) => {
+    // JAP@Add: 'auto' is only valid through makeWASocketAuto() — the version
+    // lookup is network-async while this factory is sync. Fail loudly instead
+    // of letting WA reject the handshake with a confusing 405 later.
+    if (config?.version === 'auto') {
+        throw new Error("version: 'auto' requires the async factory: use `await makeWASocketAuto(config)` (or call fetchBestWaVersion() yourself and pass its version).");
+    }
     const newConfig = {
         ...DEFAULT_CONNECTION_CONFIG,
         ...config
@@ -49,4 +55,21 @@ const makeWASocket = (config) => {
     sock.sendHumanized = (jid, content, humanOpts, sendOptions) => sendHumanizedWithSock(sock, jid, content, humanOpts, sendOptions);
     return sock;
 };
+/**
+ * JAP@Add --- async factory with automatic WA Web version resolution.
+ * `await makeWASocketAuto(config)` resolves the freshest client version via
+ * fetchBestWaVersion() (WA's own sw.js -> baileys fork -> hardcoded fallback,
+ * never throws) before opening the socket — the same stale-version guard the
+ * Framework Bot already has, now for direct socket users. A pinned
+ * `config.version` array is respected untouched; `version: 'auto'` (or no
+ * version at all) triggers the lookup.
+ */
+export const makeWASocketAuto = async (config = {}) => {
+    const { version, ...rest } = config;
+    if (Array.isArray(version)) {
+        return makeWASocket(config);
+    }
+    const best = await fetchBestWaVersion();
+    return makeWASocket({ ...rest, version: best.version });
+};
 export default makeWASocket;

package/lib/Utils/auto-reconnect.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Drop-in auto-reconnect for direct makeWASocket users (the Framework Bot
+ * already has this built in). Exponential backoff with jitter, never
+ * reconnects on loggedOut, immediate reconnect on restartRequired.
+ * @author J.AP
+ */
+
+export interface AutoReconnectOptions {
+    /** Called with every fresh socket (initial + each reconnect) — attach your event handlers here. */
+    onSocket?: (sock: any) => void;
+    /** Called when a connection reaches 'open'. */
+    onOpen?: (sock: any) => void;
+    /** Called once when the session is logged out (no reconnect will follow) — clean up creds here. */
+    onLoggedOut?: (error: unknown) => void;
+    /** Give up after this many consecutive failed attempts (default Infinity). */
+    maxAttempts?: number;
+    /** First retry delay in ms (default 1000). */
+    baseDelayMs?: number;
+    /** Backoff cap in ms (default 30000). */
+    maxDelayMs?: number;
+    /** Random jitter fraction 0-1 applied to each delay (default 0.25). */
+    jitter?: number;
+    logger?: any;
+}
+
+export interface AutoReconnectManager {
+    /** Create the socket (via your factory) and begin supervising it. Resolves to the socket, or null if already stopped. */
+    start: () => Promise<any | null>;
+    /** Cancel pending reconnects and close the live socket. */
+    stop: () => Promise<void>;
+    /** The live socket (replaced on every reconnect); null before start(). */
+    readonly socket: any | null;
+    /** Consecutive failed attempts since the last successful open. */
+    readonly attempts: number;
+}
+
+/**
+ * Supervise a socket factory with automatic reconnect.
+ * The factory may be sync (`() => makeWASocket(cfg)`) or async
+ * (`() => makeWASocketAuto(cfg)`).
+ */
+export declare const autoReconnect: (
+    socketFactory: () => any | Promise<any>,
+    options?: AutoReconnectOptions,
+) => AutoReconnectManager;

package/lib/Utils/auto-reconnect.js

@@ -0,0 +1,125 @@
+/**
+ * JAP@Add --- drop-in auto-reconnect for direct makeWASocket users.
+ *
+ * The Framework Bot has always had exponential-backoff reconnect built in;
+ * plain-socket users had to hand-roll the same connection.update dance every
+ * project (the #1 beginner Baileys question). This wraps it once, correctly:
+ *
+ *   const manager = autoReconnect(() => makeWASocketAuto({ auth: state }), {
+ *       onSocket: (sock) => sock.ev.on('messages.upsert', handler),
+ *   });
+ *   await manager.start();
+ *
+ * - exponential backoff with jitter (1s base -> 30s cap)
+ * - never reconnects on DisconnectReason.loggedOut (session is dead; caller
+ *   gets onLoggedOut to clean up creds)
+ * - restartRequired (post-pairing) reconnects immediately, not backed off
+ * - stop() cancels timers and closes the live socket
+ * - factory may be async (works with makeWASocketAuto) or sync
+ *
+ * @author J.AP
+ */
+import { DisconnectReason } from '../Types/index.js';
+import defaultLogger from './logger.js';
+
+export const autoReconnect = (socketFactory, options = {}) => {
+    const {
+        onSocket,
+        onOpen,
+        onLoggedOut,
+        maxAttempts = Infinity,
+        baseDelayMs = 1000,
+        maxDelayMs = 30000,
+        jitter = 0.25,
+        logger = defaultLogger.child({ module: 'auto-reconnect' }),
+    } = options;
+
+    let sock = null;
+    let attempts = 0;
+    let timer = null;
+    let stopped = false;
+
+    const delayFor = (attempt) => {
+        const exp = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt - 1));
+        const wiggle = exp * jitter * (Math.random() * 2 - 1);
+        return Math.max(0, Math.round(exp + wiggle));
+    };
+
+    const start = async () => {
+        if (stopped) {
+            return null;
+        }
+        sock = await socketFactory();
+        try {
+            onSocket?.(sock);
+        }
+        catch (err) {
+            logger.warn({ err }, 'onSocket handler threw');
+        }
+        sock.ev.on('connection.update', (update) => {
+            const { connection, lastDisconnect } = update;
+            if (connection === 'open') {
+                attempts = 0;
+                try {
+                    onOpen?.(sock);
+                }
+                catch (err) {
+                    logger.warn({ err }, 'onOpen handler threw');
+                }
+                return;
+            }
+            if (connection !== 'close' || stopped) {
+                return;
+            }
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            if (statusCode === DisconnectReason.loggedOut) {
+                logger.info('session logged out — not reconnecting');
+                try {
+                    onLoggedOut?.(lastDisconnect?.error);
+                }
+                catch (err) {
+                    logger.warn({ err }, 'onLoggedOut handler threw');
+                }
+                return;
+            }
+            attempts += 1;
+            if (attempts > maxAttempts) {
+                logger.warn({ attempts: attempts - 1 }, 'max reconnect attempts reached — giving up');
+                return;
+            }
+            const immediate = statusCode === DisconnectReason.restartRequired;
+            const delay = immediate ? 0 : delayFor(attempts);
+            logger.info({ attempt: attempts, delay, statusCode }, 'scheduling reconnect');
+            timer = setTimeout(() => {
+                timer = null;
+                start().catch((err) => logger.error({ err }, 'reconnect attempt failed'));
+            }, delay);
+        });
+        return sock;
+    };
+
+    const stop = async () => {
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        try {
+            await sock?.end?.();
+        }
+        catch { /* socket may already be dead */ }
+    };
+
+    return {
+        start,
+        stop,
+        /** The live socket (replaced on every reconnect); null before start(). */
+        get socket() {
+            return sock;
+        },
+        /** Consecutive failed attempts since the last successful open. */
+        get attempts() {
+            return attempts;
+        },
+    };
+};

package/lib/Utils/index.d.ts

@@ -53,5 +53,6 @@ export * from "./history-share.js";
 export * from "./transcribe.js";
 export * from "./auth-secure.js";
 export * from "./qr-render.js";
+export * from "./auto-reconnect.js";
 
 export * from "./MessageBuilder.js";

package/lib/Utils/index.js

@@ -54,3 +54,4 @@ export * from './history-share.js';
 export * from './auth-secure.js';
 export * from './transcribe.js';
 export * from './qr-render.js';
+export * from './auto-reconnect.js';

package/lib/Utils/media-messages.js

@@ -5,7 +5,21 @@
  * changeprofileFull, generateProfilePictureFP === generatePP (source had
  * these as byte-identical pairs under different names).
  */
-import { Jimp, JimpMime } from 'jimp';
+// JAP@Fix: jimp is lazy-loaded (same pattern as better-sqlite3 /
+// fluent-ffmpeg / node-webpmux elsewhere in this fork). A static top-level
+// import made every consumer pay ~200ms startup + ~11MB heap for an image
+// library only the profile-picture helpers use, and broke browser-targeting
+// bundlers (jimp@1.6.x ships an empty `export {}` stub as its browser entry,
+// so bundlephobia/esbuild-web resolved Jimp/JimpMime to nothing). Node's
+// module registry caches the dynamic import, so the cost is paid once per
+// process on first use — repeat calls hit the cache at ~0ms.
+let jimpModule = null;
+const loadJimp = async () => {
+    if (!jimpModule) {
+        jimpModule = await import('jimp');
+    }
+    return jimpModule;
+};
 const toBuffer = async (stream) => {
     const chunks = [];
     for await (const chunk of stream) {
@@ -20,6 +34,7 @@ const toBuffer = async (stream) => {
  * target, preserving aspect ratio throughout.
  */
 const generateWideProfilePicture = async (img) => {
+    const { Jimp, JimpMime } = await loadJimp();
     const jimp = await Jimp.read(img);
     const width = jimp.bitmap.width;
     const height = jimp.bitmap.height;
@@ -36,6 +51,7 @@ export const changeprofileFull = generateWideProfilePicture;
  * within 720x720) plus a normalized preview buffer.
  */
 const generateSquareProfilePicture = async (buffer) => {
+    const { Jimp, JimpMime } = await loadJimp();
     const jimp = await Jimp.read(buffer);
     const img = await jimp.clone().scaleToFit({ w: 720, h: 720 }).getBuffer(JimpMime.jpeg);
     const preview = await jimp.clone().normalize().getBuffer(JimpMime.jpeg);
@@ -60,6 +76,7 @@ export const generateProfilePicturee = async (mediaUpload) => {
     else {
         bufferOrFilePath = await toBuffer(mediaUpload.stream);
     }
+    const { Jimp, JimpMime } = await loadJimp();
     const jimp = await Jimp.read(bufferOrFilePath);
     const { width, height } = jimp.bitmap;
     const resized = width > height

package/lib/index.d.ts

@@ -14,5 +14,6 @@ export type { VoipClientConfig, AnswerCallOptions, JoinGroupCallOptions, StartGr
 export type { UsernameSocketMethods, SetUsernameOptions, CheckUsernameResult, FoundUsernameUser } from "./Socket/username.js";
 export * from "./Builders/index.js";
 export { makeWASocket };
+export { makeWASocketAuto } from "./Socket/index.js";
 export default makeWASocket;
 import makeWASocket from './Socket/index.js';

package/lib/index.js

@@ -16,6 +16,7 @@ export { Bot, Context, MediaManager, SessionManager, StatsManager, SQLiteStore }
 // lib/VoIP/index.js for usage — instantiate VoipClient(sock) after connection.open.
 export { VoipClient, ActiveCall, CallState, attachVoip, createWavRecorder } from './VoIP/index.js';
 export { makeWASocket };
+export { makeWASocketAuto } from './Socket/index.js';
 export default makeWASocket;
 
 // Jap Builders

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@japofc/baileys",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Feature-rich WhatsApp Multi-Device library for Node.js — interactive messages, native flows, polls, newsletters, VoIP, mini-apps and everyday bot utilities.",
   "type": "module",
   "main": "./lib/index.js",
@@ -175,6 +175,7 @@
   "devDependencies": {
     "@types/node": "^22.20.2",
     "jsqr": "^1.4.0",
-    "typescript": "^7.0.2"
+    "typedoc": "^0.28.20",
+    "typescript": "6.0.x"
   }
 }