kage-baileys 3.0.0 → 3.0.2

package/Example/connection.cjs

@@ -29,6 +29,7 @@ async function connect() {
     auth ||= await useMultiFileAuthState(path.join(dataDir, 'auth'));
     sock = makeWASocket({
         logger,
+        kageTools: { banner: true, eventTracking: true, statusTracking: true },
         auth: { creds: auth.state.creds, keys: makeCacheableSignalKeyStore(auth.state.keys, logger) },
         browser: Browsers.macOS('Desktop'),
         syncFullHistory: process.env.KAGE_FULL_HISTORY !== '0',
@@ -40,6 +41,9 @@ async function connect() {
         getMessage: async key => (await store.loadMessage(key.remoteJid, key.id))?.message
     });
     store.bind(sock.ev);
+    sock.ev.on('kage.event', event => {
+        if (['call', 'unsupported'].includes(event.kind)) logger.info(event, 'Evento detectado');
+    });
     sock.ev.on('creds.update', () => {
         credsWrite = credsWrite.then(() => auth.saveCreds()).catch(error => {
             logger.error({ error }, 'Error de escritura de credenciales; se detiene para no perder la sesión');

package/lib/Socket/chats.js

@@ -737,7 +737,7 @@ const makeChatsSocket = (config) => {
             return jid;
         }
         if ((0, WABinary_1.isLidUser)(jid)) {
-            return (0, WABinary_1.lidToJid)(jid);
+            return (0, WABinary_1.jidNormalizedUser)(jid);
         }
         return jid;
     };
@@ -770,7 +770,7 @@ const makeChatsSocket = (config) => {
         }
         return keys;
     };
-    const getDedupState = (msg) => msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT
+    const getDedupState = (msg) => ['ciphertext', 'stub', 'unknown'].includes(require('../Utils/message-inspector').inspectMessage(msg).type)
         ? 'ciphertext'
         : 'final';
     const getPendingDedupState = (dedupState) => dedupState === 'final' ? 'processing' : dedupState;

package/lib/Socket/messages-recv.js

@@ -766,7 +766,8 @@ const makeMessagesRecvSocket = (config) => {
         const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc');
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
         if (encNode && encNode.attrs.type === 'msmsg') {
-            logger.debug({ key: node.attrs.key }, 'ignored msmsg');
+            logger.warn({ id: node.attrs.id, from: node.attrs.from }, 'msmsg no compatible: contenido cifrado no procesado');
+            ev.emit('kage.unsupported-message', { id: node.attrs.id, chat: node.attrs.from, encryption: 'msmsg', reason: 'UNSUPPORTED_ENCRYPTION' });
             await sendMessageAck(node);
             return;
         }
@@ -822,7 +823,9 @@ const makeMessagesRecvSocket = (config) => {
                         // no type in the receipt => message delivered
                         let type = undefined;
                         if ((_b = msg.key.participant) === null || _b === void 0 ? void 0 : _b.endsWith('@lid')) {
-                            msg.key.participant = node.attrs.participant_pn || authState.creds.me.id;
+                            const originalLid = msg.key.participant;
+                            const mapped = node.attrs.participant_pn || await Promise.resolve(signalRepository.lidMapping?.getPNForLID?.(originalLid)).catch(() => undefined);
+                            if (mapped) { msg.key.participantAlt = originalLid; msg.key.participant = mapped; }
                         }
                         if ((0, WABinary_1.isJidGroup)(msg.key.remoteJid) && ((_f = (_e = (_d = (_c = msg.message) === null || _c === void 0 ? void 0 : _c.extendedTextMessage) === null || _d === void 0 ? void 0 : _d.contextInfo) === null || _e === void 0 ? void 0 : _e.participant) === null || _f === void 0 ? void 0 : _f.endsWith('@lid'))) {
                             if (msg.message.extendedTextMessage.contextInfo) {
@@ -835,9 +838,10 @@ const makeMessagesRecvSocket = (config) => {
                             void warmupGroupParticipants(msg.key.remoteJid);
                         }
                         if (!(0, WABinary_1.isJidGroup)(msg.key.remoteJid) && (0, WABinary_1.isLidUser)(msg.key.remoteJid)) {
-                            msg.key.remoteJid = node.attrs.sender_pn
-                                || node.attrs.peer_recipient_pn
-                                || (0, WABinary_1.lidToJid)(msg.key.remoteJid);
+                            const originalLid = msg.key.remoteJid;
+                            const mapped = node.attrs.sender_pn || node.attrs.peer_recipient_pn
+                                || await Promise.resolve(signalRepository.lidMapping?.getPNForLID?.(originalLid)).catch(() => undefined);
+                            if (mapped) { msg.key.remoteJidAlt = originalLid; msg.key.remoteJid = mapped; }
                         }
                         let participant = msg.key.participant;
                         if (category === 'peer') { // special peer message

package/lib/Utils/automation-tools.js

@@ -8,7 +8,7 @@ function unwrapNormalMedia(raw) {
   let msg = raw?.message;
   for (let i = 0; i < 12 && msg; i++) {
     if (msg.viewOnceMessage || msg.viewOnceMessageV2 || msg.viewOnceMessageV2Extension) throw new Error('VIEW_ONCE_PROTECTED: pide al remitente una copia normal con su consentimiento.');
-    const wrapper = ['ephemeralMessage', 'documentWithCaptionMessage'].find(k => msg[k]?.message);
+    const wrapper = ['deviceSentMessage', 'ephemeralMessage', 'documentWithCaptionMessage'].find(k => msg[k]?.message);
     if (wrapper) { msg = msg[wrapper].message; continue; }
     for (const type of ['imageMessage', 'videoMessage', 'audioMessage', 'documentMessage', 'stickerMessage']) {
       if (!msg[type]) continue;
@@ -33,16 +33,32 @@ async function downloadNormalMedia(conn, raw, options = {}) {
   const chunks = [];
   let size = 0;
   const job = (async () => {
-    stream = await download({ ...raw, message: media.message }, 'stream', { options: { timeout: timeoutMs } }, { logger, reuploadRequest: conn.updateMediaMessage?.bind(conn) });
-    if (stopped) { stream.destroy?.(); throw new Error('MEDIA_TIMEOUT'); }
-    for await (const chunk of stream) {
-      if (stopped) throw new Error('MEDIA_TIMEOUT');
-      const data = Buffer.from(chunk); size += data.length;
-      if (size > maxBytes) throw new Error('MEDIA_TOO_LARGE: se interrumpió al alcanzar el límite.');
-      chunks.push(data);
+    let target = { ...raw, message: media.message };
+    for (let attempt = 0; attempt < 2; attempt++) {
+      chunks.length = 0; size = 0;
+      try {
+        stream = await download(target, 'stream', { options: { timeout: timeoutMs } }, { logger, reuploadRequest: conn.updateMediaMessage?.bind(conn) });
+        if (stopped) { stream.destroy?.(); throw new Error('MEDIA_TIMEOUT'); }
+        for await (const chunk of stream) {
+          if (stopped) throw new Error('MEDIA_TIMEOUT');
+          const data = Buffer.from(chunk); size += data.length;
+          if (size > maxBytes) throw new Error('MEDIA_TOO_LARGE: se interrumpió al alcanzar el límite.');
+          chunks.push(data);
+        }
+        if (!size) throw new Error('EMPTY_MEDIA: WhatsApp no entregó datos.');
+        return { buffer: Buffer.concat(chunks, size), type: media.type, mimetype: media.value.mimetype || 'application/octet-stream', caption: media.value.caption || '', bytes: size };
+      } catch (error) {
+        stream?.destroy?.();
+        const code = error?.output?.statusCode || error?.response?.status || error?.statusCode;
+        const retry = [403,404,408,410,429,500,502,503,504].includes(Number(code)) || /EMPTY_MEDIA|ECONNRESET|ETIMEDOUT|ENOTFOUND/.test(error?.message || error?.code || '');
+        if (attempt || stopped || !retry) throw error;
+        if ([403,404,410].includes(Number(code)) && typeof conn.updateMediaMessage === 'function') {
+          const updated = await conn.updateMediaMessage(target);
+          if (updated?.message) target = updated;
+        }
+        if (stopped) throw new Error('MEDIA_TIMEOUT');
+      }
     }
-    if (!size) throw new Error('EMPTY_MEDIA: WhatsApp no entregó datos.');
-    return { buffer: Buffer.concat(chunks, size), type: media.type, mimetype: media.value.mimetype || 'application/octet-stream', caption: media.value.caption || '', bytes: size };
   })();
   try {
     return await Promise.race([job, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('MEDIA_TIMEOUT: tiempo de espera agotado.')), timeoutMs); })]);
@@ -96,7 +112,7 @@ function handleAutoMedia(raw, conn, settings = {}, options = {}) {
   while (state.seen.size > 500) state.seen.delete(state.seen.keys().next().value);
   state.pending++;
   const job = state.tail.then(() => saveNormalMedia(conn, raw, options));
-  state.tail = job.catch(() => {}).finally(() => { state.pending--; });
+  state.tail = job.catch(() => { state.seen.delete(id); }).finally(() => { state.pending--; });
   return job;
 }
 async function sendAIResponse(conn, jid, text, options = {}) {
@@ -113,8 +129,13 @@ function installKageTools(conn, options = {}) {
   Object.defineProperty(conn, '__kageToolsInstalled', { value: true });
   const status = require('./status-tools');
   const country = require('./country-info');
+  conn.inspectMessage = raw => require('./message-inspector').inspectMessage(raw);
+  conn.getMessageDiagnostics = () => require('./message-inspector').getMessageDiagnostics(conn);
+  conn.enableEventTracking = opts => require('./message-inspector').installMessageInspector(conn, opts);
+  conn.refreshReceivedStatuses = opts => require('./status-refresh').refreshReceivedStatuses(conn, opts);
+  if (options.eventTracking) conn.enableEventTracking(options.eventOptions || {});
+  if (options.banner) require('./terminal-banner').showKageBanner();
   conn.getReceivedStatuses = (includeUnavailable = false) => status.listStatuses(conn, includeUnavailable);
-  conn.reactToReceivedStatus = (entry, emoji) => status.reactToStatus(conn, entry, emoji);
   conn.getCountryForJid = jid => country.getCountryForJid(conn, jid);
   conn.downloadNormalMedia = (raw, opts) => downloadNormalMedia(conn, raw, opts);
   conn.saveNormalMedia = (raw, opts) => saveNormalMedia(conn, raw, opts);
@@ -130,17 +151,25 @@ function installKageTools(conn, options = {}) {
   conn.enableMediaAutomation = (settings = {}) => {
     if (conn.__kageStopMedia) return conn.__kageStopMedia;
     let active = true;
+    const recent = new Map();
     const scoped = new Proxy(settings, { get(target, key) { return !active && ['autoDownloadChats','autoViewOnceChats','autoViewOnceConsent'].includes(key) ? undefined : target[key]; } });
     const upsert = event => {
-      if (event?.type !== 'notify') return;
+      if (event?.type && !['notify', 'append'].includes(event.type)) return;
       for (const raw of event.messages || []) {
+        const id = JSON.stringify([raw.key?.remoteJid, raw.key?.id]);
+        if (raw.messageTimestamp) recent.set(id, raw.messageTimestamp);
+        while(recent.size > 1000) recent.delete(recent.keys().next().value);
         handleAutoMedia(raw, conn, scoped).catch(error => conn.logger?.warn?.({ error: error.message }, 'media automation'));
         require('./view-once-compat').handleAutoViewOnce(raw, conn, scoped).catch(error => conn.logger?.warn?.({ error: error.message }, 'view once automation'));
       }
     };
-    const stop = () => { active = false; conn.ev.off('messages.upsert', upsert); conn.ev.off('connection.update', closed); delete conn.__kageStopMedia; };
+    const updated = items => { for (const item of items || []) if (item.update?.message) {
+      const timestamp = item.update.messageTimestamp || recent.get(JSON.stringify([item.key?.remoteJid, item.key?.id]));
+      if (timestamp) upsert({ type: 'append', messages: [{ ...item.update, key: item.key, messageTimestamp: timestamp }] });
+    } };
+    const stop = () => { active = false; recent.clear(); conn.ev.off('messages.update', updated); conn.ev.off('messages.upsert', upsert); conn.ev.off('connection.update', closed); delete conn.__kageStopMedia; };
     const closed = update => { if (update.connection === 'close') stop(); };
-    conn.ev.on('messages.upsert', upsert); conn.ev.on('connection.update', closed);
+    conn.ev.on('messages.upsert', upsert); conn.ev.on('messages.update', updated); conn.ev.on('connection.update', closed);
     conn.__kageStopMedia = stop;
     return stop;
   };
@@ -150,13 +179,18 @@ function installKageTools(conn, options = {}) {
   conn.enableStatusTracking = (settings = {}) => {
     if (stop) return stop;
     let active = true;
-    const scopedSettings = new Proxy(settings, { get(target, key) { return key === 'statusReaction' ? active && target[key] : target[key]; } });
+    const scopedSettings = new Proxy(settings, { get(target, key) { return key === 'statusSave' ? active && target[key] : target[key]; } });
     const upsert = event => { for (const raw of event?.messages || []) status.handleStatus(raw, conn, scopedSettings).catch(e => conn.logger?.warn?.({ error: e.message }, 'status tracking')); };
+    const history = event => upsert(event);
     const deleted = event => { for (const key of event?.keys || []) status.markStatusDeleted(conn, key); };
-    const updated = items => { for (const item of items || []) if (item.key?.remoteJid === 'status@broadcast' && item.update?.message === null) status.markStatusDeleted(conn, item.key); };
+    const updated = items => { for (const item of items || []) {
+      if (item.key?.remoteJid === 'status@broadcast' && item.update?.message === null) status.markStatusDeleted(conn, item.key);
+      else if (item.update?.message) upsert({ messages: [{ ...item.update, key: item.key }] });
+    } }; 
     const closed = update => { if (update.connection === 'close') stop?.(); };
     const timer = setInterval(() => status.flushStatuses(conn), 60000); timer.unref?.();
     conn.ev.on('messages.upsert', upsert);
+    conn.ev.on('messaging-history.set', history);
     conn.ev.on('messages.delete', deleted);
     conn.ev.on('messages.update', updated);
     conn.ev.on('connection.update', closed);
@@ -164,7 +198,7 @@ function installKageTools(conn, options = {}) {
       if (!active) return;
       active = false;
       clearInterval(timer);
-      conn.ev.off('messages.upsert', upsert); conn.ev.off('messages.delete', deleted);
+      conn.ev.off('messages.upsert', upsert); conn.ev.off('messaging-history.set', history); conn.ev.off('messages.delete', deleted);
       conn.ev.off('messages.update', updated); conn.ev.off('connection.update', closed);
       status.flushStatuses(conn); stop = undefined;
     };

package/lib/Utils/message-inspector.js

@@ -0,0 +1,105 @@
+'use strict';
+const states = new WeakMap();
+const wrappers = ['deviceSentMessage', 'ephemeralMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension', 'documentWithCaptionMessage', 'editedMessage', 'statusMentionMessage', 'groupStatusMentionMessage', 'groupStatusMessage', 'groupStatusMessageV2'];
+const labels = { conversation:'Texto', extendedTextMessage:'Texto', imageMessage:'Imagen', videoMessage:'Video', audioMessage:'Audio', documentMessage:'Documento', stickerMessage:'Sticker', reactionMessage:'Reacción', encReactionMessage:'Reacción cifrada', contactMessage:'Contacto', contactsArrayMessage:'Contactos', locationMessage:'Ubicación', liveLocationMessage:'Ubicación en vivo', pollCreationMessage:'Encuesta', pollCreationMessageV2:'Encuesta', pollCreationMessageV3:'Encuesta', pollUpdateMessage:'Voto de encuesta', protocolMessage:'Protocolo', interactiveMessage:'Interactivo', interactiveResponseMessage:'Respuesta interactiva', buttonsResponseMessage:'Respuesta de botón', listResponseMessage:'Respuesta de lista', eventMessage:'Evento programado', call:'Llamada', scheduledCallCreationMessage:'Llamada programada' };
+const clean = jid => String(jid || '').replace(/:\d+@/, '@');
+const numeric = n => { const value = Number(n?.toNumber?.() ?? n ?? 0); return Number.isFinite(value) ? value : 0; };
+function inspectMessage(raw = {}) {
+  let message = raw.message || raw.fakeObj?.message || {};
+  const layers = [];
+  for (let i=0; i<16; i++) {
+    const wrapper = wrappers.find(k => message[k]?.message);
+    if (!wrapper) break;
+    layers.push(wrapper); message = message[wrapper].message;
+  }
+  const keys = Object.keys(message).filter(k => message[k] != null && !['messageContextInfo','senderKeyDistributionMessage','fastRatchetKeySenderKeyDistributionMessage'].includes(k));
+  const type = keys.find(k => labels[k]) || keys[0] || '';
+  const value = typeof message[type] === 'object' ? message[type] : {};
+  const context = value?.contextInfo || {};
+  const key = raw.key || raw.fakeObj?.key || {};
+  const chat = clean(key.remoteJid || raw.chat);
+  const group = chat.endsWith('@g.us');
+  const stubType = numeric(raw.messageStubType);
+  const encrypted = stubType === 2 && !type;
+  const viewOnce = layers.some(k=>k.startsWith('viewOnce')) || value?.viewOnce === true;
+  const text = typeof message[type] === 'string' ? message[type] : value?.text || value?.caption || '';
+  return {
+    id: key.id || raw.id || null, chat, chatAlt: clean(key.remoteJidAlt) || null,
+    sender: clean(key.participant || raw.participant || raw.sender || (!key.fromMe && !group && chat !== 'status@broadcast' ? chat : '')) || null,
+    senderAlt: clean(key.participantAlt) || null, fromMe: !!key.fromMe,
+    route: chat === 'status@broadcast' ? 'estado' : group ? 'grupo' : chat.endsWith('@newsletter') ? 'canal' : /@(s\.whatsapp\.net|lid)$/.test(chat) ? 'privado' : 'sistema',
+    type: type || (encrypted ? 'ciphertext' : stubType ? 'stub' : 'unknown'),
+    label: encrypted ? 'Mensaje cifrado pendiente de descifrar' : labels[type] || (stubType ? 'Aviso del sistema' : type || 'Sin contenido'),
+    wrappers: layers, viewOnce, ephemeral: layers.includes('ephemeralMessage') || numeric(context.expiration)>0,
+    ptt: !!value?.ptt, gif: !!value?.gifPlayback, mime: value?.mimetype || null,
+    bytes: numeric(value?.fileLength) || (typeof text === 'string' ? Buffer.byteLength(text) : 0),
+    width: numeric(value?.width), height: numeric(value?.height), seconds: numeric(value?.seconds),
+    timestamp: numeric(raw.messageTimestamp), stubType: stubType || null,
+    quotedId: context.stanzaId || null, mentions: (context.mentionedJid || []).slice(0,100),
+    forwarded: !!context.isForwarded, forwardingScore: numeric(context.forwardingScore),
+    downloadable: !!(value?.mediaKey && (value?.directPath || value?.url)), encrypted,
+    receivedAt: Date.now()
+  };
+}
+function stateFor(conn) {
+  let state=states.get(conn);
+  if(!state){state={events:[],messages:new Map(),counts:{},listeners:[],stopped:false};states.set(conn,state);}
+  return state;
+}
+function rememberMessage(conn, raw) {
+  const info=inspectMessage(raw); const state=stateFor(conn);
+  if(info.id){
+    const key=JSON.stringify([info.chat,info.sender,info.id,info.fromMe]);
+    const previous=state.messages.get(key) || [...state.messages.values()].find(item=>item.chat===info.chat&&item.id===info.id&&item.fromMe===info.fromMe);
+    if (!info.timestamp && previous) info.timestamp=previous.timestamp;
+    if (!info.sender && previous) info.sender=previous.sender;
+    state.messages.set(key,info);
+  }
+  for(const [key,info] of state.messages) if(Date.now()-info.receivedAt>86400000) state.messages.delete(key);
+  while(state.messages.size>1000) state.messages.delete(state.messages.keys().next().value);
+  return info;
+}
+function installMessageInspector(conn, options={}) {
+  const state=stateFor(conn);
+  if(state.stop && !state.stopped) return state.stop;
+  state.stopped=false;
+  const record=(kind,detail)=>{
+    const event={kind,time:Date.now(),...detail};
+    state.events.push(event); while(state.events.length>100) state.events.shift();
+    state.counts[kind]=(state.counts[kind]||0)+1;
+    conn.ev.emit('kage.event',event);
+    if(typeof options.onEvent==='function') { try{options.onEvent(event);}catch(error){conn.logger?.warn?.({error:error.message},'event monitor callback');} }
+  };
+  const bind=(name,callback)=>{conn.ev.on(name,callback);state.listeners.push([name,callback]);};
+  bind('messages.upsert',data=>{for(const raw of data?.messages||[]) record('message',rememberMessage(conn,raw));});
+  bind('messaging-history.set',data=>{for(const raw of data?.messages||[]) rememberMessage(conn,raw);record('history',{count:data?.messages?.length||0});});
+  bind('messages.update',items=>{for(const item of items||[]) {
+    if(item.update?.message) record('message.updated',rememberMessage(conn,{...item.update,key:item.key}));
+    else record('message.receipt',{id:item.key?.id,chat:clean(item.key?.remoteJid),status:item.update?.status ?? null,deleted:item.update?.message===null});
+  }});
+  bind('messages.delete',data=>record('message.deleted',{keys:(data?.keys||[]).slice(0,100).map(k=>({id:k.id,chat:clean(k.remoteJid)})),all:!!data?.all}));
+  bind('messages.reaction',items=>{for(const item of items||[]) record('reaction',{id:item.key?.id,chat:clean(item.key?.remoteJid),emoji:item.reaction?.text||''});});
+  bind('message-receipt.update',items=>{for(const item of items||[]) record('receipt',{id:item.key?.id,chat:clean(item.key?.remoteJid),user:clean(item.receipt?.userJid)});});
+  bind('call',calls=>{for(const call of calls||[]) record('call',{id:call.id,chat:clean(call.chatId||call.from),from:clean(call.from),status:call.status,isVideo:!!call.isVideo,isGroup:!!call.isGroup});});
+  bind('presence.update',data=>record('presence',{chat:clean(data?.id),users:Object.entries(data?.presences||{}).slice(0,30).map(([jid,p])=>({jid:clean(jid),state:p?.lastKnownPresence}))}));
+  bind('group-participants.update',data=>record('group.participants',{chat:clean(data?.id),action:data?.action,participants:(data?.participants||[]).slice(0,100).map(p=>typeof p==='string'?p:p.id)}));
+  bind('groups.update',items=>{for(const item of items||[])record('group.updated',{chat:clean(item.id),fields:Object.keys(item).filter(k=>k!=='id')});});
+  bind('chats.upsert',items=>record('chats.upsert',{chats:(items||[]).map(item=>clean(item.id)).slice(0,100)}));
+  bind('chats.update',items=>record('chats.update',{chats:(items||[]).map(item=>clean(item.id)).slice(0,100)}));
+  bind('contacts.upsert',items=>record('contacts.upsert',{count:items?.length||0}));
+  bind('contacts.update',items=>record('contacts.update',{count:items?.length||0}));
+  bind('kage.automation',data=>record('automation.'+String(data.kind||'media'),{id:data.id,chat:clean(data.chat),outcome:data.outcome,error:data.error||null}));
+  bind('kage.unsupported-message',data=>record('unsupported',{id:data?.id,chat:clean(data?.chat),encryption:data?.encryption,reason:data?.reason}));
+  bind('connection.update',data=>{record('connection',{connection:data.connection||null,receivedPendingNotifications:data.receivedPendingNotifications??null});if(data.connection==='close')state.stop();});
+  state.stop=()=>{if(state.stopped)return;state.stopped=true;for(const [name,fn]of state.listeners)conn.ev.off(name,fn);state.listeners=[];};
+  return state.stop;
+}
+function getMessageDiagnostics(conn) {
+  const state=stateFor(conn);
+  // Never expose references to internal mutable buffers or credentials.
+  return JSON.parse(JSON.stringify({active:!!state.stop&&!state.stopped,counts:state.counts,recent:state.events, messages:[...state.messages.values()]}));
+}
+exports.inspectMessage=inspectMessage;
+exports.rememberMessage=rememberMessage;
+exports.installMessageInspector=installMessageInspector;
+exports.getMessageDiagnostics=getMessageDiagnostics;

package/lib/Utils/status-refresh.js

@@ -0,0 +1,37 @@
+'use strict';
+const cooldowns=new WeakMap();
+async function refreshReceivedStatuses(conn, options={}) {
+  const status=require('./status-tools');
+  const capture=options.capture || (raw=>status.captureStatus(raw,conn));
+  const list=options.list || (()=>status.listStatuses(conn));
+  let state=cooldowns.get(conn);if(!state){state={last:0,keys:new Map(),job:null};cooldowns.set(conn,state);}
+  if(state.job)return state.job;
+  if(Date.now()-state.last<10000)return {received:list().length,imported:0,requested:0,errors:[],throttled:true};
+  state.last=Date.now();
+  state.job=(async()=>{
+    let imported=0,requested=0;const errors=[];
+    const sources=[options.messages,conn.chats?.['status@broadcast']?.messages,options.store?.messages?.['status@broadcast']];
+    if(options.capture) sources.push(status.listStatuses(conn).map(entry=>entry.raw).filter(Boolean));
+    for(const source of sources){
+      const items=Array.isArray(source)?source:source instanceof Map?[...source.values()]:source?.array||[];
+      for(const raw of items.slice(-500))if(raw?.key?.remoteJid==='status@broadcast'&&capture(raw))imported++;
+    }
+    const entries=list();
+    // There is no arbitrary status-list query here. Request only known message keys delivered to us.
+    const missing=entries.filter(entry=>!entry.type&&entry.sourceKey?.id&&!['expired','deleted'].includes(entry.availability)&&entry.expiresAt>Date.now());
+    for(const entry of missing.slice(0,5)){
+      const key=JSON.stringify([entry.author,entry.sourceKey.id]);
+      if(Date.now()-(state.keys.get(key)||0)<60000)continue;
+      if(typeof conn.requestPlaceholderResend!=='function')break;
+      state.keys.set(key,Date.now()); requested++;
+      let timer;
+      try { await Promise.race([conn.requestPlaceholderResend(entry.sourceKey),new Promise((_,reject)=>{timer=setTimeout(()=>reject(new Error('STATUS_REFRESH_PENDING')),4000);})]); }
+      catch(error){errors.push({id:entry.id,error:String(error.message||error).slice(0,200)});}
+      finally{clearTimeout(timer);}
+    }
+    for(const [key,time]of state.keys)if(Date.now()-time>86400000)state.keys.delete(key);
+    return {received:list().length,imported,requested,errors,throttled:false};
+  })();
+  try{return await state.job;}finally{state.job=null;}
+}
+exports.refreshReceivedStatuses=refreshReceivedStatuses;

package/lib/Utils/status-tools.js

@@ -2,7 +2,7 @@
 // Estados recibidos por ESTA conexión. No consulta estados ocultos ni audiencias privadas.
 const { mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync } = require('node:fs')
 const { resolve, join } = require('node:path')
-const { createHash, randomInt } = require('node:crypto')
+const { createHash } = require('node:crypto')
 const reportError = (area, error) => console.error(`[${area}]`, error?.message || error)
 const caches = new WeakMap()
 const DAY = 86_400_000
@@ -19,8 +19,10 @@ function persist(state) {
 }
 function stateFor(conn) {
   let state = caches.get(conn)
+  const identity = normalizeJid(conn.user?.jid || conn.user?.id)
+  if (state && state.account !== identity) { persist(state); caches.delete(conn); state = null }
   if (!state) {
-    state = { entries: new Map(), next: 1, last: 0, busy: false }
+    state = { entries: new Map(), next: 1, last: 0, busy: false, account: identity }
     const account = normalizeJid(conn.user?.jid || conn.user?.id)
     if (account && conn.statusStorageDir !== false) {
       state.dir = resolve(conn.statusStorageDir || 'data/status')
@@ -71,7 +73,7 @@ function statusContent(message = {}) {
   const contexts = []
   for (let i = 0; i < 12 && current; i++) {
     for (const value of Object.values(current)) if (value?.contextInfo) contexts.push(value.contextInfo)
-    const key = ['ephemeralMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension',
+    const key = ['deviceSentMessage', 'ephemeralMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension',
       'documentWithCaptionMessage', 'statusMentionMessage', 'groupStatusMentionMessage', 'groupStatusMessage', 'groupStatusMessageV2']
       .find(name => current[name]?.message)
     if (!key) break
@@ -155,8 +157,9 @@ function captureStatus(raw, conn) {
     viewOnce: !!(old?.viewOnce || info.wrappers.some(w => /viewOnce/.test(w))),
     routes: [...new Set([...(old?.routes || []), raw.key.remoteJid])]
   }
-  state.entries.set(identity, entry); prune(state); persist(state)
-  return entry
+  const stored = old ? Object.assign(old, entry) : entry
+  state.entries.set(identity, stored); prune(state); persist(state)
+  return stored
 }
 function listStatuses(conn, includeUnavailable = false) { const state = stateFor(conn); prune(state); return [...state.entries.values()].filter(e => includeUnavailable || !['deleted', 'expired'].includes(e.availability)).sort((a, b) => a.receivedAt - b.receivedAt) }
 function findStatus(conn, selector = '') {
@@ -164,27 +167,6 @@ function findStatus(conn, selector = '') {
   return listStatuses(conn, true).find(entry => entry.id === id || entry.sourceKey?.id === selector)
 }
 function clearStatuses(conn) { const state = stateFor(conn); const count = state.entries.size; for (const entry of state.entries.values()) retire(entry, 'expired', Date.now()); state.entries.clear(); persist(state); return count }
-function isStatusEmoji(text) {
-  if (typeof text !== 'string' || text.length > 32 || !/\p{Extended_Pictographic}|\p{Regional_Indicator}|\u20e3/u.test(text)) return false
-  return [...new Intl.Segmenter('es', { granularity: 'grapheme' }).segment(text)].length === 1
-}
-async function reactToStatus(conn, entry, emoji, options = {}) {
-  if (!isStatusEmoji(emoji)) throw new Error('Escribe un solo emoji, por ejemplo ❤️, 👍🏽 o 👨‍👩‍👧‍👦.')
-  if (!entry || ['deleted', 'expired'].includes(entry.availability) || entry.expiresAt <= Date.now()) throw new Error('Ese estado ya no está disponible en la caché.')
-  if (!entry.sourceKey?.id || !/@(s\.whatsapp\.net|lid)$/.test(entry.author)) throw new Error('La notificación no incluye la clave y el autor originales; no es posible reaccionar con seguridad.')
-  const self = normalizeJid(conn.user?.jid || conn.user?.id)
-  if (entry.author === self || entry.author === normalizeJid(conn.user?.lid) || entry.sourceKey.fromMe) throw new Error('No se reacciona a los estados de la propia cuenta.')
-  const state = stateFor(conn)
-  if (state.busy) throw new Error('Hay otra reacción en curso; espera unos segundos.')
-  const interval = Math.max(1000, Number(options.intervalMs ?? global.safety?.statusReactionIntervalMs) || 5000)
-  if (Date.now() - state.last < interval) throw new Error('Espera unos segundos entre reacciones.')
-  state.busy = true; state.last = Date.now()
-  try {
-    if (typeof conn.readMessages === 'function') await conn.readMessages([entry.sourceKey])
-    await conn.sendMessage('status@broadcast', { react: { text: emoji, key: entry.sourceKey } }, { statusJidList: [entry.author] })
-    entry.reactedWith = emoji; entry.reactedAt = Date.now(); state.last = Date.now(); persist(state)
-  } finally { state.busy = false }
-}
 async function handleStatus(raw, conn, settings = {}) {
   if (raw?.key?.remoteJid !== 'status@broadcast') return false
   const entry = captureStatus(raw, conn)
@@ -192,27 +174,8 @@ async function handleStatus(raw, conn, settings = {}) {
     try { await require('./status-archive').handleStatusArchive(conn, entry, settings, settings.archiveOptions || {}) }
     catch (error) { reportError('status-archive', error) }
   }
-  if (!entry || !settings.statusReaction || raw.key.fromMe || entry.reactedAt) return true
-  const state = stateFor(conn)
-  state.scheduled ||= new Set()
-  if (state.scheduled.has(entry.id) || state.scheduled.size >= 30) return true
-  state.scheduled.add(entry.id)
-  const task = (state.reactionTail || Promise.resolve()).then(async () => {
-    const gap = Math.max(1000, Number(settings.statusReactionIntervalMs ?? global.safety?.statusReactionIntervalMs) || 5000)
-    const wait = Math.max(0, state.last + gap - Date.now())
-    if (wait) await new Promise(resolve => setTimeout(resolve, wait))
-    if (!settings.statusReaction || entry.reactedAt || ['deleted', 'expired'].includes(entry.availability)) return
-    const pool = Array.isArray(settings.statusEmojis) ? settings.statusEmojis.filter(isStatusEmoji) : ['❤️', '🔥', '👍', '😊', '👏', '💜']
-    const emoji = settings.statusEmojiMode === 'random' ? pool.length ? pool[randomInt(pool.length)] : '❤️' : settings.statusEmoji || '❤️'
-    if (!isStatusEmoji(emoji)) return
-    const self = normalizeJid(conn.user?.jid || conn.user?.id)
-    if (!entry.author || entry.author === self || entry.author === normalizeJid(conn.user?.lid)) return
-    await reactToStatus(conn, entry, emoji, { intervalMs: gap })
-  })
-  state.reactionTail = task.catch(error => reportError('reacciones-estados', error)).finally(() => state.scheduled.delete(entry.id))
   return true
 }
-async function waitStatusReactions(conn) { await stateFor(conn).reactionTail }
 
 exports.markStatusDeleted = markStatusDeleted;
 exports.flushStatuses = flushStatuses;
@@ -221,8 +184,5 @@ exports.captureStatus = captureStatus;
 exports.listStatuses = listStatuses;
 exports.findStatus = findStatus;
 exports.clearStatuses = clearStatuses;
-exports.isStatusEmoji = isStatusEmoji;
-exports.reactToStatus = reactToStatus;
 exports.handleStatus = handleStatus;
 
-exports.waitStatusReactions = waitStatusReactions;

package/lib/Utils/terminal-banner.js

@@ -0,0 +1,32 @@
+'use strict';
+const chalk=require('chalk');
+const gradient=require('gradient-string');
+const tinyMap=Object.fromEntries([...('abcdefghijklmnopqrstuvwxyz')].map((c,i)=>[c,[...'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ'][i]]));
+function say(text, options={}) {
+  const stream=options.stream||process.stdout;
+  let rendered=String(text??'').replace(/[\x00-\x08\x0b-\x1f\x7f]/g,'');
+  if(options.font==='tiny')rendered=[...rendered.toLowerCase()].map(c=>tinyMap[c]||c).join('');
+  else if(options.font==='block')rendered=rendered.toUpperCase().split('\n').map(line=>'▰ '+[...line].join(' ')+' ▰').join('\n');
+  else if(options.font==='simple')rendered=rendered.toUpperCase();
+  const width=Number(options.width)||stream.columns||80;
+  const color=options.forceColor??!!stream.isTTY;
+  const colors=(options.colors||[]).filter(name=>typeof chalk[name]==='function');
+  rendered=rendered.split('\n').map((line,i)=>{
+    const pad=options.align==='center'?Math.max(0,Math.floor((width-[...line].length)/2)):options.align==='right'?Math.max(0,width-[...line].length):0;
+    let output=line;
+    if(color&&Array.isArray(options.gradient)&&options.gradient.length>=2){try{output=gradient(options.gradient)(line);}catch{}}
+    else if(color&&colors.length){const paint=new chalk.Instance({level:1});output=[...line].map((char,index)=>paint[colors[(index+i)%colors.length]](char)).join('');}
+    return ' '.repeat(Math.min(500,pad))+output;
+  }).join('\n');
+  stream.write(rendered+'\n'); return rendered;
+}
+let shown=false;
+function showKageBanner(options={}) {
+  if(shown||process.env.KAGE_BANNER==='0')return;
+  shown=true;
+  say('kage baileys',{font:'block',align:'center',gradient:['red','magenta'],...options});
+  say('Creado por xrljosedv',{font:'console',align:'center',colors:['cyan','magenta','yellow'],...options});
+  say('Mensajes · Estados · Llamadas',{font:'tiny',align:'center',colors:['cyan','blue'],...options});
+}
+exports.say=say;
+exports.showKageBanner=showKageBanner;

package/lib/Utils/view-once-compat.js

@@ -7,7 +7,7 @@ function getViewOnceContent(raw) {
   let message = raw?.message ?? raw;
   let viewOnce = false;
   for (let i = 0; i < 12 && message && typeof message === 'object'; i++) {
-    const wrapper = ['ephemeralMessage', 'documentWithCaptionMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'].find(k => message[k]?.message);
+    const wrapper = ['deviceSentMessage', 'ephemeralMessage', 'documentWithCaptionMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'].find(k => message[k]?.message);
     if (wrapper) { viewOnce ||= wrapper.startsWith('viewOnce'); message = message[wrapper].message; continue; }
     const type = types.find(k => message[k]);
     if (!type) return null;
@@ -40,12 +40,19 @@ async function resendViewOnceMessage(conn, raw, options = {}) {
   if (field === 'document') body.fileName = value.fileName || 'archivo';
   return conn.sendMessage(options.jid || raw.key.remoteJid, body, options.quoted ? { quoted: options.quoted } : {});
 }
-function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
+async function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
   const chat = raw?.key?.remoteJid;
-  const active = () => Array.isArray(settings.autoViewOnceChats) && settings.autoViewOnceChats.includes(chat);
+  const normalize = jid => String(jid || '').replace(/:\d+@/, '@');
+  const aliases = new Set([chat, raw?.key?.remoteJidAlt].filter(Boolean).map(normalize));
+  for (const jid of [...aliases]) {
+    if (jid.endsWith('@lid')) {
+      try { const pn = await conn.signalRepository?.lidMapping?.getPNForLID?.(jid); if (pn) aliases.add(normalize(pn)); } catch {}
+    }
+  }
+  const active = () => Array.isArray(settings.autoViewOnceChats) && settings.autoViewOnceChats.some(jid => aliases.has(normalize(jid)));
   // Preserve the explicitly consented archive API for existing library clients.
   if (!active()) return require('./consented-media').handleConsentedAutoViewOnce(raw, conn, settings, options);
-  if (!raw?.key?.id || raw.key.fromMe || !/@(s\.whatsapp\.net|lid|g\.us)$/.test(chat || '') || !getViewOnceContent(raw)?.viewOnce) return Promise.resolve(null);
+  if (!raw?.key?.id || (raw.key.fromMe && !settings.autoViewOnceOwn) || !/@(s\.whatsapp\.net|lid|g\.us)$/.test(chat || '') || !getViewOnceContent(raw)?.viewOnce) return Promise.resolve(null);
   const timestamp = Number(raw.messageTimestamp?.toNumber?.() ?? raw.messageTimestamp ?? 0) * 1000;
   if (!timestamp || Date.now() - timestamp > 300000 || timestamp > Date.now() + 60000) return Promise.resolve(null);
   let state = queues.get(conn);
@@ -58,7 +65,8 @@ function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
   state.seen.set(id, now); state.pending++;
   while (state.seen.size > 500) state.seen.delete(state.seen.keys().next().value);
   const task = state.tail.then(() => active() ? resendViewOnceMessage(conn, raw, { ...options, jid: chat, shouldSend: active }) : null);
-  state.tail = task.catch(() => {}).finally(() => { state.pending--; });
+  task.then(result => conn.ev?.emit('kage.automation', { kind: 'viewonce', id: raw.key.id, chat, outcome: result ? 'sent' : 'cancelled' }), error => conn.ev?.emit('kage.automation', { kind: 'viewonce', id: raw.key.id, chat, outcome: 'failed', error: String(error.message || error).slice(0,200) })).catch(error => conn.logger?.warn?.({ error: error.message }, 'automation event listener'));
+  state.tail = task.catch(() => { state.seen.delete(id); }).finally(() => { state.pending--; });
   return task;
 }
 exports.getViewOnceContent = getViewOnceContent;

package/lib/index.d.ts

@@ -193,8 +193,8 @@ export declare const extractSyncdPatches: any;
 export declare const extractUrlFromText: any;
 export declare const extractVideoThumb: any;
 export declare const fetchLatestBaileysVersion: any;
+export declare const fetchLatestKageVersion: any;
 export declare const fetchLatestWaWebVersion: any;
-export declare const fetchLatestWileysVersion: any;
 export declare const findStatus: any;
 export declare const flushStatuses: any;
 export declare const generateCodeBlockContent: any;
@@ -249,6 +249,7 @@ export declare const getHistoryMsg: any;
 export declare const getHttpStream: any;
 export declare const getKeyAuthor: any;
 export declare const getMediaKeys: any;
+export declare const getMessageDiagnostics: any;
 export declare const getMessageReportingToken: any;
 export declare const getNextPreKeys: any;
 export declare const getNextPreKeysNode: any;
@@ -272,7 +273,9 @@ export declare const hkdf: any;
 export declare const hkdfInfoKey: any;
 export declare const hmacSign: any;
 export declare const initAuthCreds: any;
+export declare const inspectMessage: any;
 export declare const installKageTools: any;
+export declare const installMessageInspector: any;
 export declare const isJidBot: any;
 export declare const isJidBroadcast: any;
 export declare const isJidGroup: any;
@@ -283,7 +286,6 @@ export declare const isJidUser: any;
 export declare const isKnownStatusContact: any;
 export declare const isLidUser: any;
 export declare const isRealMessage: any;
-export declare const isStatusEmoji: any;
 export declare const isWABusinessPlatform: any;
 export declare const jidDecode: any;
 export declare const jidEncode: any;
@@ -313,17 +315,20 @@ export declare const processContactAction: any;
 export declare const processHistoryMessage: any;
 export declare const processSyncAction: any;
 export declare const promiseTimeout: any;
-export declare const reactToStatus: any;
 export declare const readAndEmitEventStream: any;
 export declare const reduceBinaryNodeToDictionary: any;
+export declare const refreshReceivedStatuses: any;
+export declare const rememberMessage: any;
 export declare const resendViewOnceMessage: any;
 export declare const saveConsentedViewOnce: any;
 export declare const saveNormalMedia: any;
 export declare const saveReceivedStatus: any;
+export declare const say: any;
 export declare const sendAIResponse: any;
 export declare const sha256: any;
 export declare const shouldIncludeReportingToken: any;
 export declare const shouldIncrementChatUnread: any;
+export declare const showKageBanner: any;
 export declare const signedKeyPair: any;
 export declare const statusContent: any;
 export declare const toBuffer: any;
@@ -344,7 +349,6 @@ export declare const uploadFile: any;
 export declare const useMultiFileAuthState: any;
 export declare const version: any;
 export declare const vid2jpg: any;
-export declare const waitStatusReactions: any;
 export declare const writeRandomPadMax16: any;
 export declare const xmppPreKey: any;
 export declare const xmppSignedPreKey: any;

package/lib/index.js

@@ -95,7 +95,7 @@ for (const __p of __kageExtraModules) {
     try { __kageMergeSafe(require(__p)); } catch (__e) { /* opcional */ }
 }
 try { __kageMergeSafe(require("./VoIP/index.js")); } catch (__e) { /* VoIP opcional */ }
-exports.KAGE_BUILD = Object.freeze({ name: "kage-baileys", version: "1.1.8" });
+exports.KAGE_BUILD = Object.freeze({ name: "kage-baileys", version: "3.0.1", revision: "recepcion-automatica-1" });
 
 __exportStar(require("./Utils/status-tools.js"), exports);
 __exportStar(require("./Utils/country-info.js"), exports);
@@ -104,3 +104,7 @@ __exportStar(require("./Utils/automation-tools.js"), exports);
 __exportStar(require("./Utils/consented-media.js"), exports);
 __exportStar(require("./Utils/view-once-compat.js"), exports);
 __exportStar(require("./Utils/status-archive.js"), exports);
+
+__exportStar(require("./Utils/message-inspector.js"), exports);
+__exportStar(require("./Utils/status-refresh.js"), exports);
+__exportStar(require("./Utils/terminal-banner.js"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kage-baileys",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Kage Baileys una libreria de WhatsApp.",
   "keywords": [
     "kage-baileys",
@@ -39,7 +39,8 @@
     "check": "npm run lint && npm test",
     "example": "node Example/connection.cjs",
     "gen:types": "node scripts/generate-public-types.cjs",
-    "check:engine": "node engine-requirements.js"
+    "check:engine": "node engine-requirements.js",
+    "prepublishOnly": "npm run gen:protobuf && npm run gen:types && npm run check"
   },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
@@ -71,7 +72,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "protobufjs-cli": "2.7.1",
+    "protobufjs-cli": "^2.7.1",
     "typescript": "^5.8.2"
   },
   "peerDependencies": {

package/test/installation-repair.test.cjs

@@ -38,6 +38,6 @@ test('package update helper requests a real npm version document', async () => {
 });
 test('package fallback is the installed library version, not a WhatsApp version', async () => {
  await mocked(async()=>{throw new Error('offline')},async()=>{
-  const result=await fetchLatestKageVersion();assert.deepEqual(result.version,[1,1,8]);assert.equal(result.isLatest,false);
+  const result=await fetchLatestKageVersion();assert.deepEqual(result.version,require('../package.json').version.split('.').map(Number));assert.equal(result.isLatest,false);
  });
 });

package/test/recepcion-reparada.test.cjs

@@ -0,0 +1,98 @@
+'use strict';
+const test=require('node:test');const assert=require('node:assert/strict');
+const {EventEmitter}=require('node:events');const {Readable}=require('node:stream');
+const fs=require('node:fs');const os=require('node:os');const path=require('node:path');
+const api=require('../lib');
+const chat='51900000001@s.whatsapp.net';
+const socket=()=>({ev:new EventEmitter(),user:{id:'51900000002:1@s.whatsapp.net'},statusStorageDir:false,sent:[],async sendMessage(jid,body){const sent={jid,body};this.sent.push(sent);return sent;}});
+const raw=(type='imageMessage',wrapper='viewOnceMessageV2',route=chat)=>({key:{remoteJid:route,participant:route.endsWith('@g.us')?chat:undefined,id:'fresh',fromMe:false},messageTimestamp:Math.floor(Date.now()/1000),message:{[wrapper]:{message:{[type]:{viewOnce:true,mediaKey:Buffer.from('secret'),directPath:'/delivered',mimetype:type==='audioMessage'?'audio/ogg':'application/octet-stream',ptt:type==='audioMessage'}}}}});
+const download=async()=>Readable.from([Buffer.from('delivered-content')]);
+for(const type of ['imageMessage','videoMessage','audioMessage','documentMessage','stickerMessage'])for(const wrapper of ['viewOnceMessage','viewOnceMessageV2','viewOnceMessageV2Extension']){
+ test(`inspección conserva ${wrapper}/${type}`,()=>{
+  const message=raw(type,wrapper),before=JSON.stringify(message),detail=api.inspectMessage(message);
+  assert.equal(detail.type,type);assert.equal(detail.viewOnce,true);assert.equal(detail.downloadable,true);assert.equal(JSON.stringify(message),before);assert.equal(JSON.stringify(detail).includes('secret'),false);
+ });
+}
+for(const route of [chat,'123456@g.us'])for(const type of ['imageMessage','videoMessage','audioMessage'])test(`automático usa misma salida manual: ${route}/${type}`,async()=>{
+ const a=socket(),b=socket(),message=raw(type,'viewOnceMessageV2Extension',route);
+ await api.resendViewOnceMessage(a,message,{downloader:download});
+ await api.handleAutoViewOnce(message,b,{autoViewOnceChats:[route]},{downloader:download});
+ assert.deepEqual(b.sent,a.sent);assert.equal(b.sent.length,1);
+});
+test('deviceSentMessage y efímero no ocultan la vista única',async()=>{
+ const c=socket(),message=raw();message.message={deviceSentMessage:{message:{ephemeralMessage:{message:message.message}}}};
+ await api.handleAutoViewOnce(message,c,{autoViewOnceChats:[chat]},{downloader:download});assert.equal(c.sent.length,1);assert.equal(api.inspectMessage(message).viewOnce,true);
+});
+test('permiso de privado PN funciona con LID confirmado',async()=>{
+ const c=socket();c.signalRepository={lidMapping:{getPNForLID:async()=>chat}};
+ await api.handleAutoViewOnce(raw('imageMessage','viewOnceMessageV2','999@lid'),c,{autoViewOnceChats:[chat]},{downloader:download});assert.equal(c.sent.length,1);assert.equal(c.sent[0].jid,'999@lid');
+});
+test('un LID sin mapeo no se inventa como teléfono ni obtiene permiso',async()=>{
+ const c=socket();await api.handleAutoViewOnce(raw('imageMessage','viewOnceMessageV2','999@lid'),c,{autoViewOnceChats:['999@s.whatsapp.net']},{downloader:download});assert.equal(c.sent.length,0);assert.equal(api.inspectMessage(raw('imageMessage','viewOnceMessageV2','999@lid')).chat,'999@lid');
+});
+test('medios propios solo se copian mediante autorización explícita',async()=>{
+ const c=socket(),message=raw();message.key.fromMe=true;
+ await api.handleAutoViewOnce(message,c,{autoViewOnceChats:[chat]},{downloader:download});assert.equal(c.sent.length,0);
+ await api.handleAutoViewOnce(message,c,{autoViewOnceChats:[chat],autoViewOnceOwn:true},{downloader:download});assert.equal(c.sent.length,1);
+ const normal={...message,key:{...message.key,id:'normal-output'},message:{imageMessage:{}}};await api.handleAutoViewOnce(normal,c,{autoViewOnceChats:[chat],autoViewOnceOwn:true},{downloader:download});assert.equal(c.sent.length,1);
+});
+test('fallo no deja el ID bloqueado para la siguiente entrega',async()=>{
+ const c=socket(),message=raw(),settings={autoViewOnceChats:[chat]};
+ await assert.rejects(api.handleAutoViewOnce(message,c,settings,{downloader:async()=>{throw new Error('fallo controlado');}}),/fallo controlado/);
+ await api.handleAutoViewOnce(message,c,settings,{downloader:download});assert.equal(c.sent.length,1);
+});
+test('descarga renueva referencia 404 y reintenta una vez',async()=>{
+ const c=socket();let downloads=0,reuploads=0;
+ c.updateMediaMessage=async message=>{reuploads++;return message;};
+ const result=await api.downloadViewOnceMessage(c,raw(),{downloader:async()=>{if(!downloads++){const e=new Error('CDN 404');e.response={status:404};throw e;}return download();}});
+ assert.equal(result.buffer.toString(),'delivered-content');assert.equal(downloads,2);assert.equal(reuploads,1);
+});
+test('fallo persistente se detiene tras dos intentos',async()=>{
+ let calls=0;await assert.rejects(api.downloadViewOnceMessage(socket(),raw(),{downloader:async()=>{calls++;const e=new Error('CDN 410');e.statusCode=410;throw e;}}),/CDN 410/);assert.equal(calls,2);
+});
+test('vista única automática no procesa historial antiguo',async()=>{
+ const c=socket(),message=raw();message.messageTimestamp=1;
+ await api.handleAutoViewOnce(message,c,{autoViewOnceChats:[chat]},{downloader:download});assert.equal(c.sent.length,0);
+});
+test('aviso cifrado no se clasifica como medio disponible',()=>{
+ const info=api.inspectMessage({key:{remoteJid:chat,id:'pending'},messageStubType:2});assert.equal(info.type,'ciphertext');assert.equal(info.encrypted,true);assert.match(info.label,/pendiente/);
+});
+test('monitor detecta llamadas, presencia, reacciones y cierra sin listeners duplicados',()=>{
+ const c=api.installKageTools(socket()),stop=c.enableEventTracking();assert.equal(c.enableEventTracking(),stop);
+ c.ev.emit('call',[{id:'call1',from:chat,status:'offer',isVideo:true}]);
+ c.ev.emit('presence.update',{id:chat,presences:{[chat]:{lastKnownPresence:'composing'}}});
+ c.ev.emit('messages.reaction',[{key:{id:'reaction',remoteJid:chat},reaction:{text:'👍'}}]);
+ const diag=c.getMessageDiagnostics();assert.equal(diag.counts.call,1);assert.equal(diag.counts.presence,1);assert.equal(diag.counts.reaction,1);assert.equal(diag.recent[0].isVideo,true);
+ stop();assert.equal(c.ev.listenerCount('call'),0);assert.equal(c.ev.listenerCount('messages.upsert'),0);assert.equal(c.getMessageDiagnostics().active,false);
+});
+test('diagnóstico acotado no almacena claves de medios ni texto',()=>{
+ const c=api.installKageTools(socket());const stop=c.enableEventTracking();
+ for(let i=0;i<120;i++){const m=raw();m.key.id='m'+i;c.ev.emit('messages.upsert',{messages:[m],type:'notify'});}
+ const diag=c.getMessageDiagnostics();assert.equal(diag.recent.length,100);assert.equal(diag.messages.length,120);assert.equal(JSON.stringify(diag).includes('secret'),false);stop();
+});
+test('estado de historial y actualización descifrada se reindexa',async()=>{
+ const c=api.installKageTools(socket());const stop=c.enableStatusTracking();
+ const key={remoteJid:'status@broadcast',participant:chat,id:'status1'};const timestamp=Math.floor(Date.now()/1000);
+ c.ev.emit('messaging-history.set',{messages:[{key,messageTimestamp:timestamp,message:{conversation:'publicado'}}]});
+ assert.equal(c.getReceivedStatuses().length,1);
+ c.ev.emit('messages.update',[{key,update:{messageTimestamp:timestamp,message:{imageMessage:{mimetype:'image/jpeg'}}}}]);
+ await new Promise(r=>setImmediate(r));assert.equal(c.getReceivedStatuses()[0].type,'imageMessage');stop();
+});
+test('actualización de estados usa solo claves conocidas, sin consultar estados ocultos',async()=>{
+ const c=socket();api.captureStatus({key:{remoteJid:'status@broadcast',participant:chat,id:'missing'},messageTimestamp:Math.floor(Date.now()/1000),message:{}},c);
+ const requests=[];c.requestPlaceholderResend=async key=>requests.push(key);
+ const report=await api.refreshReceivedStatuses(c);assert.equal(report.requested,1);assert.equal(requests[0].id,'missing');
+ assert.equal((await api.refreshReceivedStatuses(c)).throttled,true);
+});
+test('caché consultada antes del login carga su archivo al conocerse la cuenta',()=>{
+ const dir=fs.mkdtempSync(path.join(os.tmpdir(),'status-login-'));
+ try{
+  const a=socket();a.statusStorageDir=dir;api.captureStatus({key:{remoteJid:'status@broadcast',participant:chat,id:'saved'},messageTimestamp:Math.floor(Date.now()/1000),message:{conversation:'persistido'}},a);
+  const b={statusStorageDir:dir};assert.equal(api.listStatuses(b).length,0);b.user=a.user;assert.equal(api.listStatuses(b).length,1);
+ }finally{fs.rmSync(dir,{recursive:true,force:true});}
+});
+test('banner admite fuentes y colores sin efectos al importar',()=>{
+ const lines=[];const stream={columns:60,isTTY:false,write:text=>lines.push(text)};
+ for(const font of ['simple','console','tiny','block'])api.say('kage baileys',{font,align:'center',gradient:['red','magenta'],stream});
+ assert.equal(lines.length,4);assert.match(lines[0],/KAGE BAILEYS/);assert.match(lines[3],/▰/);
+});

package/test/revision.test.cjs

@@ -11,8 +11,6 @@ const countries = require('../lib/Utils/countries.json');
 const examples = require('libphonenumber-js/examples.mobile.json');
 const raw = (id = 'S1', author = '51987654321@s.whatsapp.net', message = { conversation: 'Hola' }) => ({ key: { remoteJid: 'status@broadcast', participant: author, id, fromMe: false }, messageTimestamp: Math.floor(Date.now()/1000), message });
 const socket = () => ({ user: { id: '34612345678:2@s.whatsapp.net' }, statusStorageDir: false, sendMessage: async () => ({}), readMessages: async () => {}, ev: new EventEmitter() });
-for (const emoji of ['❤️','🔥','👍','👍🏽','👨‍👩‍👧‍👦','😊','🇵🇪','1️⃣','💜','👏','🌈','🏳️‍🌈','🧑🏽‍💻','🫶','☀️','⭐','🐕','💯','😀','🎉']) test(`emoji accepted: ${emoji}`, () => assert.equal(api.isStatusEmoji(emoji), true));
-for (const value of ['', 'hola', '❤️🔥', 'a❤️', '123', null, 2, ' ', '\n', '👍 👍', 'x', '🇵🇪🇲🇽', '❤️'.repeat(30)]) test(`emoji rejected: ${JSON.stringify(value)}`, () => assert.equal(api.isStatusEmoji(value), false));
 for (const code of ['PE','MX','ES','AR','CO','CL','EC','BO','BR','US','CA','GB','FR','DE','IT','JP','KR','AU','NZ','IN','ZA','EG','MA','UY','PY','VE','CR','PA','DO','GT']) test(`offline country lookup ${code}`, () => {
   const info = api.getCountryInfo(require('libphonenumber-js').getExampleNumber(code, examples).number);
   assert.ok(info, code); assert.equal(info.code, code); assert.equal(info.name, countries[code].name);
@@ -100,23 +98,6 @@ test('status cache bounded to 500 entries', () => {
   const c = socket(); for (let i=0;i<510;i++) api.captureStatus(raw('id-'+i),c);
   assert.equal(api.listStatuses(c).length,500); assert.equal(api.clearStatuses(c),500);
 });
-test('manual reaction uses status route, real message key and emoji', async () => {
-  const c = socket(); let sent; c.sendMessage = async (...args) => { sent=args; };
-  const e = api.captureStatus(raw(),c); await api.reactToStatus(c,e,'👍🏽');
-  assert.equal(sent[0],'status@broadcast'); assert.equal(sent[1].react.text,'👍🏽'); assert.deepEqual(sent[2].statusJidList,[e.author]);
-});
-test('cannot react to deleted or self statuses', async () => {
-  const c = socket(); const e = api.captureStatus(raw(),c); api.markStatusDeleted(c,e.sourceKey);
-  await assert.rejects(api.reactToStatus(c,e,'🔥'), /disponible/);
-  const self = api.captureStatus(raw('self','34612345678@s.whatsapp.net'),c);
-  await assert.rejects(api.reactToStatus(c,self,'🔥'), /propia cuenta/);
-});
-test('random reaction uses configured emoji pool and deduplicates delivery', async () => {
-  const c = socket(); const sent=[]; c.sendMessage=async (...args) => { sent.push(args); };
-  const settings = { statusReaction:true,statusEmojiMode:'random',statusEmojis:['🔥','💜'] };
-  await api.handleStatus(raw(),c,settings); await api.handleStatus(raw(),c,settings); await api.waitStatusReactions(c);
-  assert.equal(sent.length,1); assert.ok(settings.statusEmojis.includes(sent[0][1].react.text));
-});
 test('socket bindings install and detach status listeners without duplicates', async () => {
   const c = socket(); api.installKageTools(c); api.installKageTools(c);
   const stop = c.enableStatusTracking(); assert.equal(c.enableStatusTracking(),stop); assert.equal(c.ev.listenerCount('messages.upsert'),1);
@@ -140,14 +121,6 @@ test('browser presets support documented calls and missing browser', () => {
   assert.equal(api.Browsers().length,3); assert.doesNotThrow(()=>api.getPlatformId());
 });
 
-test('automatic reaction queue processes a burst with configured pacing', async () => {
-  const c = socket(); const sent=[];
-  c.sendMessage = async (...args) => { sent.push({ time: Date.now(), args }); };
-  const settings = { statusReaction: true, statusEmoji: '🔥', statusReactionIntervalMs: 1000 };
-  await api.handleStatus(raw('first'), c, settings); await api.handleStatus(raw('second'), c, settings);
-  await api.waitStatusReactions(c);
-  assert.equal(sent.length,2); assert.ok(sent[1].time - sent[0].time >= 990);
-});
 test('detaching status tracking never overwrites persisted activation setting', () => {
   const c = socket(); api.installKageTools(c); const settings = { statusReaction: true };
   const stop = c.enableStatusTracking(settings); stop(); stop();

package/test/status-policy.test.cjs

@@ -0,0 +1,40 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const api = require('../lib');
+const raw = id => ({ key: { remoteJid: 'status@broadcast', participant: '51987654321@s.whatsapp.net', id }, messageTimestamp: Math.floor(Date.now()/1000), message: { conversation: 'estado' } });
+const socket = () => ({ user: { id: '34612345678@s.whatsapp.net' }, statusStorageDir: false, ev: new EventEmitter(), sent: [], async sendMessage(...args) { this.sent.push(args); } });
+test('Baileys has no application-level status reaction exports or socket method', () => {
+  for (const name of ['reactToStatus', 'waitStatusReactions', 'isStatusEmoji']) assert.equal(api[name], undefined);
+  const conn = api.installKageTools(socket());
+  assert.equal(conn.reactToReceivedStatus, undefined);
+});
+test('statusReaction settings never send reactions from Baileys', async () => {
+  const conn = socket();
+  await api.handleStatus(raw('A'), conn, { statusReaction: true, statusEmoji: '🔥' });
+  await api.handleStatus(raw('A'), conn, { statusReaction: true });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(conn.sent.length, 0);
+  assert.equal(api.listStatuses(conn).length, 1);
+});
+test('optional status tracking only records received statuses', async () => {
+  const conn = api.installKageTools(socket());
+  const stop = conn.enableStatusTracking({ statusReaction: true });
+  conn.ev.emit('messages.upsert', { type: 'notify', messages: [raw('B')] });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(conn.sent.length, 0);
+  assert.equal(conn.getReceivedStatuses().length, 1);
+  stop();
+  assert.equal(conn.ev.listenerCount('messages.upsert'), 0);
+});
+test('official status reaction schema survives encoding and decoding', () => {
+  const source = { reactionMessage: { key: { remoteJid: 'status@broadcast', participant: '51987654321@s.whatsapp.net', id: 'ORIGINAL', fromMe: false }, text: '❤️', senderTimestampMs: '1770000000000' } };
+  const message = api.proto.Message.fromObject(source);
+  assert.equal(api.proto.Message.verify(message), null);
+  const decoded = api.proto.Message.decode(api.proto.Message.encode(message).finish());
+  assert.equal(decoded.reactionMessage.text, '❤️');
+  assert.equal(decoded.reactionMessage.key.id, 'ORIGINAL');
+  assert.equal(decoded.reactionMessage.key.remoteJid, 'status@broadcast');
+  assert.equal(api.proto.MessageAssociation.AssociationType.STATUS_REACTION, 18);
+});