@systemzero/baileys 1.0.6 → 1.0.7

package/lib/Defaults/index.js

@@ -108,8 +108,8 @@ export const MEDIA_HKDF_KEY_MAPPING = {
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
 export const MIN_PREKEY_COUNT = 5;
 export const INITIAL_PREKEY_COUNT = 812;
-export const UPLOAD_TIMEOUT = 30000; // 30 seconds
-export const MIN_UPLOAD_INTERVAL = 5000; // 5 seconds minimum between uploads
+export const UPLOAD_TIMEOUT = 45000; // 45 segundos (era 30, uploads podem demorar mais em conexões lentas)
+export const MIN_UPLOAD_INTERVAL = 30000; // 30 segundos entre uploads normais (era 5s, muito agressivo)
 export const DEFAULT_CACHE_TTLS = {
     SIGNAL_STORE: 5 * 60, // 5 minutes
     MSG_RETRY: 60 * 60, // 1 hour

package/lib/Socket/messages-recv.js

@@ -1036,14 +1036,20 @@ export const makeMessagesRecvSocket = (config) => {
                                 logger.debug({ node }, 'Connection closed, skipping retry');
                                 return;
                             }
-                            // Handle pre-key errors with upload and delay
                             if (isPreKeyError) {
                                 logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying');
                                 try {
                                     logger.debug('Uploading pre-keys for error recovery');
-                                    await uploadPreKeys(5);
+                                    // Sobe mais chaves de uma vez (30 em vez de 5) — o WhatsApp
+                                    // às vezes precisa de um conjunto maior pra resolver conflitos
+                                    // de ID quando a sessão local ficou dessincronizada do servidor.
+                                    await uploadPreKeys(30, 0, true);
+                                    // Aumentado de 1000ms pra 2500ms — o servidor do WhatsApp
+                                    // precisa de mais tempo pra processar e distribuir as novas
+                                    // chaves antes de a gente tentar o retry, especialmente em
+                                    // casos de dessincronização severa.
                                     logger.debug('Waiting for server to process new pre-keys');
-                                    await delay(1000);
+                                    await delay(2500);
                                 }
                                 catch (uploadErr) {
                                     logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
@@ -1057,7 +1063,6 @@ export const makeMessagesRecvSocket = (config) => {
                         }
                         catch (err) {
                             logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry');
-                            // Still attempt retry even if pre-key upload failed
                             try {
                                 const encNode = getBinaryNodeChild(node, 'enc');
                                 await sendRetryRequest(node, !encNode);

package/lib/Socket/socket.js

@@ -311,7 +311,7 @@ export const makeSocket = (config) => {
             logger.info({ node }, 'not logged in, attempting registration...');
         }
         else {
-            node = generateLoginNode(creds.me.id, config);
+            node = generateLoginNode(creds.me.id, { ...config, auth: { creds } });
             logger.info({ node }, 'logging in...');
         }
         const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish());
@@ -342,9 +342,9 @@ export const makeSocket = (config) => {
     let uploadPreKeysPromise = null;
     let lastUploadTime = 0;
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = async (count = MIN_PREKEY_COUNT, retryCount = 0) => {
-        // Check minimum interval (except for retries)
-        if (retryCount === 0) {
+    const uploadPreKeys = async (count = MIN_PREKEY_COUNT, retryCount = 0, force = false) => {
+        // Check minimum interval (except for retries ou uploads forçados por erro de PreKey)
+        if (retryCount === 0 && !force) {
             const timeSinceLastUpload = Date.now() - lastUploadTime;
             if (timeSinceLastUpload < MIN_UPLOAD_INTERVAL) {
                 logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`);

package/lib/Utils/generics.js

@@ -277,7 +277,8 @@ export const getStatusFromReceiptType = (type) => {
     return status;
 };
 const CODE_MAP = {
-    conflict: DisconnectReason.connectionReplaced
+    conflict: DisconnectReason.connectionReplaced,
+    forbidden: DisconnectReason.forbidden
 };
 /**
  * Stream errors generally provide a reason, map that to a baileys DisconnectReason

package/lib/Utils/index.js

@@ -23,4 +23,5 @@ export * from './group-status-detection.js';
 export * from './bad-mac-handler.js';
 export * from './resolve-lid-phone.js';
 export * from './get-best-version.js';
+export * from './scheduling.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/messages.js

@@ -98,7 +98,7 @@ if (mediaType === 'audio' && uploadData.ptt === true) {
             ? uploadData.media
             : (typeof uploadData.media === 'string' ? uploadData.media : mediaUrl);
         pttTranscodedPath = await transcodeAudioToOpus(sourceForTranscode);
-        uploadData.media = pttTranscodedPath;
+        uploadData.media = { url: pttTranscodedPath };
     }
     uploadData.mimetype = 'audio/ogg; codecs=opus';
 }

package/lib/Utils/scheduling.js

@@ -0,0 +1,138 @@
+/**
+ * Message Scheduling System
+ * Ported from innovatorssoft/baileys — schedule messages to be sent automatically
+ * at specific times or after a delay.
+ *
+ * Features:
+ *  - schedule(jid, content, Date)       — send at an absolute time
+ *  - scheduleDelay(jid, content, delayMs) — send after N milliseconds
+ *  - cancel(id)                         — cancel by ID
+ *  - cancelForJid(jid)                  — cancel all pending for a JID
+ *  - getPending()                       — list all pending messages
+ *  - get(id)                            — get a single scheduled entry
+ *  - clearAll()                         — wipe the whole queue
+ *  - stop()                             — stop the internal timer
+ *  - start()                            — restart the timer
+ */
+
+export class MessageScheduler {
+    constructor(sendMessage, options = {}) {
+        this.queue = new Map();
+        this.timer = null;
+        this.sendMessage = sendMessage;
+        this.options = {
+            maxQueue:      options.maxQueue      ?? 1000,
+            checkInterval: options.checkInterval ?? 1000,
+            onSent:        options.onSent        ?? (() => {}),
+            onFailed:      options.onFailed      ?? (() => {}),
+        };
+    }
+
+    generateId() {
+        return `sched_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+
+    schedule(jid, content, scheduledTime) {
+        if (this.queue.size >= this.options.maxQueue) {
+            throw new Error(`Maximum queue size (${this.options.maxQueue}) reached`);
+        }
+        if (scheduledTime.getTime() <= Date.now()) {
+            throw new Error('Scheduled time must be in the future');
+        }
+        const scheduled = {
+            id:            this.generateId(),
+            jid,
+            content,
+            scheduledTime,
+            createdAt:     new Date(),
+            status:        'pending',
+        };
+        this.queue.set(scheduled.id, scheduled);
+        this.ensureTimerRunning();
+        return scheduled;
+    }
+
+    scheduleDelay(jid, content, delayMs) {
+        return this.schedule(jid, content, new Date(Date.now() + delayMs));
+    }
+
+    cancel(id) {
+        const scheduled = this.queue.get(id);
+        if (scheduled && scheduled.status === 'pending') {
+            scheduled.status = 'cancelled';
+            this.queue.delete(id);
+            return true;
+        }
+        return false;
+    }
+
+    cancelForJid(jid) {
+        let cancelled = 0;
+        for (const [id, scheduled] of this.queue) {
+            if (scheduled.jid === jid && scheduled.status === 'pending') {
+                scheduled.status = 'cancelled';
+                this.queue.delete(id);
+                cancelled++;
+            }
+        }
+        return cancelled;
+    }
+
+    getPending() {
+        return Array.from(this.queue.values()).filter(s => s.status === 'pending');
+    }
+
+    get(id) {
+        return this.queue.get(id);
+    }
+
+    clearAll() {
+        const count = this.queue.size;
+        this.queue.clear();
+        this.stopTimer();
+        return count;
+    }
+
+    async processQueue() {
+        const now = Date.now();
+        for (const [id, scheduled] of this.queue) {
+            if (scheduled.status !== 'pending') continue;
+            if (scheduled.scheduledTime.getTime() > now) continue;
+            try {
+                const message = await this.sendMessage(scheduled.jid, scheduled.content);
+                scheduled.status    = 'sent';
+                scheduled.messageId = message?.key?.id ?? undefined;
+                this.options.onSent(scheduled, message);
+            } catch (error) {
+                scheduled.status = 'failed';
+                scheduled.error  = error.message;
+                this.options.onFailed(scheduled, error);
+            }
+            this.queue.delete(id);
+        }
+        if (this.queue.size === 0) this.stopTimer();
+    }
+
+    ensureTimerRunning() {
+        if (!this.timer) {
+            this.timer = setInterval(() => this.processQueue(), this.options.checkInterval);
+        }
+    }
+
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+
+    stop() { this.stopTimer(); }
+
+    start() {
+        if (this.queue.size > 0) this.ensureTimerRunning();
+    }
+}
+
+export const createMessageScheduler = (sendMessage, options) => {
+    return new MessageScheduler(sendMessage, options);
+};

package/lib/Utils/validate-connection.js

@@ -48,14 +48,18 @@ const getClientPayload = (config) => {
 };
 export const generateLoginNode = (userJid, config) => {
     const { user, device } = jidDecode(userJid);
+    // lidDbMigrated: informa ao servidor se este dispositivo já completou a
+    // migração de sessão para o sistema LID. Manter como false (hardcoded)
+    // quando a conta já foi migrada faz o WhatsApp rejeitar a sessão com 403,
+    // porque o servidor espera que o cliente reconheça o estado de migração.
+    const hasLidMigrated = !!(config.auth?.creds?.myAppStateKeyId || config.auth?.creds?.lid);
     const payload = {
         ...getClientPayload(config),
         passive: true,
         pull: true,
         username: +user,
         device: device,
-        // TODO: investigate (hard set as false atm)
-        lidDbMigrated: false
+        lidDbMigrated: hasLidMigrated
     };
     return proto.ClientPayload.fromObject(payload);
 };
@@ -92,9 +96,11 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
             supportGuestChat: undefined
         },
         version: {
-            primary: 10,
-            secondary: 15,
-            tertiary: 7
+            // usa a versão real do WA passada no config, em vez de um valor
+            // fixo hardcoded (10.15.7) que fica desatualizado e pode causar 403
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
         }
     };
     const companionProto = proto.DeviceProps.encode(companion).finish();

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@systemzero/baileys",
   "type": "module",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "System-zero baileys bot",
   "keywords": [
     "whatsapp",
     "automation",
-    "whatsapp-web",
-    "whatsapp-bot"
+    "whatsapp-web"
   ],
   "publishConfig": {
     "access": "public"