kage-baileys 2.0.0 → 3.0.0

package/WAProto/p.html

@@ -1 +1 @@
-wileys
+kage

package/engine-requirements.js

@@ -1,6 +1,6 @@
 'use strict';
 const [major, minor] = process.versions.node.split('.').map(Number);
 if (major < 22 || (major === 22 && minor < 12)) {
- console.error('Kage Baileys requires Node.js >=22.12.0. Use a supported Node.js LTS release.');
+ console.error('Kage Baileys necesita Node >=22.12.0 por interoperabilidad CommonJS/ESM. Selecciona Node 22 o 24 en el panel. No basta con borrar engines.');
  process.exitCode = 1;
 }

package/lib/Store/make-in-memory-store.js

@@ -65,7 +65,7 @@ exports.default = (config = {}) => {
         return Object.keys(contacts);
     };
     /**
-     * binds to a WileysEventEmitter.
+     * binds to a KageEventEmitter.
      * It listens to all events and constructs a state that you can query accurate data from.
      * Eg. can use the store to fetch chats, contacts, messages etc.
      * @param ev typically the event emitter from the socket connection

package/lib/Utils/automation-tools.js

@@ -120,6 +120,31 @@ function installKageTools(conn, options = {}) {
   conn.saveNormalMedia = (raw, opts) => saveNormalMedia(conn, raw, opts);
   conn.downloadConsentedViewOnce = (raw, opts) => require('./consented-media').downloadConsentedViewOnce(conn, raw, opts);
   conn.saveConsentedViewOnce = (raw, opts) => require('./consented-media').saveConsentedViewOnce(conn, raw, opts);
+  conn.getViewOnceContent = raw => require('./view-once-compat').getViewOnceContent(raw);
+  conn.normalizeViewOnceMessage = raw => require('./view-once-compat').normalizeViewOnceMessage(raw);
+  conn.downloadViewOnceMessage = (raw, opts) => require('./view-once-compat').downloadViewOnceMessage(conn, raw, opts);
+  conn.resendViewOnceMessage = (raw, opts) => require('./view-once-compat').resendViewOnceMessage(conn, raw, opts);
+  conn.handleAutoViewOnce = (raw, settings, opts) => require('./view-once-compat').handleAutoViewOnce(raw, conn, settings, opts);
+  conn.saveReceivedStatus = (entry, opts) => require('./status-archive').saveReceivedStatus(conn, entry, opts);
+  conn.exportReceivedStatuses = (author, opts) => require('./status-archive').exportStatusZip(conn, author, opts);
+  conn.enableMediaAutomation = (settings = {}) => {
+    if (conn.__kageStopMedia) return conn.__kageStopMedia;
+    let active = true;
+    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;
+      for (const raw of event.messages || []) {
+        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 closed = update => { if (update.connection === 'close') stop(); };
+    conn.ev.on('messages.upsert', upsert); conn.ev.on('connection.update', closed);
+    conn.__kageStopMedia = stop;
+    return stop;
+  };
+  if (options.mediaAutomation) conn.enableMediaAutomation(options.mediaSettings || {});
   conn.sendAIResponse = (jid, text, opts) => sendAIResponse(conn, jid, text, opts);
   let stop;
   conn.enableStatusTracking = (settings = {}) => {

package/lib/Utils/consented-media.js

@@ -2,25 +2,6 @@
 const normal = require('./automation-tools');
 const queues = new WeakMap();
 const jid = value => String(value || '').replace(/:\d+@/, '@');
-function getViewOnceContent(raw) {
-  let message = raw?.message;
-  let viewOnce = false;
-  const seen = new Set();
-  for (let depth = 0; depth < 12 && message && typeof message === 'object'; depth++) {
-    if (seen.has(message)) return null;
-    seen.add(message);
-    const wrapper = ['ephemeralMessage', 'documentWithCaptionMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'].find(key => message[key]?.message);
-    if (wrapper) {
-      viewOnce ||= wrapper.startsWith('viewOnce');
-      message = message[wrapper].message;
-      continue;
-    }
-    const type = ['imageMessage', 'videoMessage', 'audioMessage', 'documentMessage', 'stickerMessage'].find(key => message[key] && typeof message[key] === 'object');
-    if (!type) return null;
-    return { type, value: message[type], message, viewOnce: viewOnce || message[type].viewOnce === true };
-  }
-  return null;
-}
 function prepareConsentedViewOnce(conn, raw, options = {}) {
   const chat = raw?.key?.remoteJid;
   if (!/^\d+@(s\.whatsapp\.net|lid)$/.test(chat || '')) throw new Error('CONSENT_PRIVATE_ONLY: solo medios propios/autorizados en privados.');
@@ -50,8 +31,7 @@ async function saveConsentedViewOnce(conn, raw, options = {}) {
 function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
   const chat = raw?.key?.remoteJid;
   const consentJid = settings.autoViewOnceConsent?.[chat];
-  if (!consentJid || !raw?.key?.id) return Promise.resolve(null);
-  if (Array.isArray(settings.autoViewOnceChats) && !settings.autoViewOnceChats.includes(chat)) return Promise.resolve(null);
+  if (!consentJid || !raw.key.id) 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);
   try { prepareConsentedViewOnce(conn, raw, { consentJid }); }
@@ -67,14 +47,13 @@ function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
   while (state.seen.size > 500) state.seen.delete(state.seen.keys().next().value);
   const task = state.tail.then(() => {
     if (settings.autoViewOnceConsent?.[chat] !== consentJid) return null;
-    if (Array.isArray(settings.autoViewOnceChats) && !settings.autoViewOnceChats.includes(chat)) return null;
     return saveConsentedViewOnce(conn, raw, { ...options, consentJid });
   });
   state.tail = task.catch(() => {}).finally(() => { state.pending--; });
   return task;
 }
-exports.getViewOnceContent = getViewOnceContent;
 exports.prepareConsentedViewOnce = prepareConsentedViewOnce;
 exports.downloadConsentedViewOnce = downloadConsentedViewOnce;
 exports.saveConsentedViewOnce = saveConsentedViewOnce;
-exports.handleAutoViewOnce = handleAutoViewOnce;
+exports.handleConsentedAutoViewOnce = handleAutoViewOnce;
+exports.handleAutoViewOnce = (...args) => require('./view-once-compat').handleAutoViewOnce(...args);

package/lib/Utils/event-buffer.js

@@ -27,14 +27,14 @@ const BUFFERABLE_EVENT_SET = new Set(BUFFERABLE_EVENT);
 /**
  * The event buffer logically consolidates different events into a single event
  * making the data processing more efficient.
- * @param ev the wileys event emitter
+ * @param ev the Kage event emitter
  */
 const makeEventBuffer = (logger) => {
     const ev = new events_1.default();
     const historyCache = new Set();
     let data = makeBufferData();
     let buffersInProgress = 0;
-    // take the generic event and fire it as a wileys event
+    // take the generic event and fire it as a Kage event
     ev.on('event', (map) => {
         for (const event in map) {
             ev.emit(event, map[event]);

package/lib/Utils/generics.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWABusinessPlatform = exports.getCodeFromWSError = exports.getCallStatusFromNode = exports.getErrorCodeFromStreamError = exports.getStatusFromReceiptType = exports.generateMdTagPrefix = exports.fetchLatestWaWebVersion = exports.fetchLatestWileysVersion = exports.fetchLatestBaileysVersion = exports.printQRIfNecessaryListener = exports.bindWaitForConnectionUpdate = exports.generateMessageID = exports.generateMessageIDV2 = exports.delayCancellable = exports.delay = exports.debouncedTimeout = exports.unixTimestampSeconds = exports.toNumber = exports.encodeBigEndian = exports.generateRegistrationId = exports.encodeNewsletterMessage = exports.encodeWAMessage = exports.unpadRandomMax16 = exports.writeRandomPadMax16 = exports.getKeyAuthor = exports.BufferJSON = exports.getPlatformId = exports.Browsers = void 0;
+exports.isWABusinessPlatform = exports.getCodeFromWSError = exports.getCallStatusFromNode = exports.getErrorCodeFromStreamError = exports.getStatusFromReceiptType = exports.generateMdTagPrefix = exports.fetchLatestWaWebVersion = exports.fetchLatestKageVersion = exports.fetchLatestBaileysVersion = exports.printQRIfNecessaryListener = exports.bindWaitForConnectionUpdate = exports.generateMessageID = exports.generateMessageIDV2 = exports.delayCancellable = exports.delay = exports.debouncedTimeout = exports.unixTimestampSeconds = exports.toNumber = exports.encodeBigEndian = exports.generateRegistrationId = exports.encodeNewsletterMessage = exports.encodeWAMessage = exports.unpadRandomMax16 = exports.writeRandomPadMax16 = exports.getKeyAuthor = exports.BufferJSON = exports.getPlatformId = exports.Browsers = void 0;
 exports.promiseTimeout = promiseTimeout;
 exports.bindWaitForEvent = bindWaitForEvent;
 exports.trimUndefined = trimUndefined;
@@ -46,7 +46,7 @@ const axios_1 = __importDefault(require("axios"));
 const crypto_1 = require("crypto");
 const os_1 = require("os");
 const WAProto_1 = require("../../WAProto");
-const wileys_version_json_1 = require("../Defaults/wileys-version.json");
+const kageVersionJson = require("../Defaults/wileys-version.json");
 const Types_1 = require("../Types");
 const WABinary_1 = require("../WABinary");
 const COMPANION_PLATFORM_MAP = {
@@ -259,48 +259,33 @@ const printQRIfNecessaryListener = (ev, logger) => {
 };
 exports.printQRIfNecessaryListener = printQRIfNecessaryListener;
 
-const fetchLatestWileysVersion = async (options = {}) => {
+const fetchLatestKageVersion = async (options = {}) => {
     try {
-        const { data } = await axios_1.default.get('https://registry.npmjs.org/wileys', {
+        const { data } = await axios_1.default.get('https://registry.npmjs.org/kage-baileys/latest', {
+            timeout: 15000,
             ...options,
             responseType: 'json'
         });
-        const versionStr = data.version;  
-        const [major, minor, patch] = versionStr.split('.').map(Number);
+        const versionStr = data.version;
+        const match = /^(\d+)\.(\d+)\.(\d+)/.exec(versionStr || '');
+        if (!match) throw new Error('Invalid Kage package version');
+        const [major, minor, patch] = match.slice(1).map(Number);
         return {
             version: [major, minor, patch],
             isLatest: true
         };
     } catch (error) {
         return {
-            version: wileys_version_json_1.version,  
+            version: require('../../package.json').version.split('-')[0].split('.').map(Number),
             isLatest: false,
             error
         };
     }
 };
-exports.fetchLatestWileysVersion = fetchLatestWileysVersion;
+exports.fetchLatestKageVersion = fetchLatestKageVersion;
 
-const fetchLatestBaileysVersion = async (options = {}) => {
-    try {
-        const { data } = await axios_1.default.get('https://registry.npmjs.org/wileys', {
-            ...options,
-            responseType: 'json'
-        });
-        const versionStr = data.version; 
-        const [major, minor, patch] = versionStr.split('.').map(Number);
-        return {
-            version: [major, minor, patch],
-            isLatest: true
-        };
-    } catch (error) {
-        return {
-            version: wileys_version_json_1.version,  
-            isLatest: false,
-            error
-        };
-    }
-};
+// WhatsApp needs its WEB protocol version, not the npm library semver.
+const fetchLatestBaileysVersion = async (options = {}) => fetchLatestWaWebVersion(options);
 exports.fetchLatestBaileysVersion = fetchLatestBaileysVersion;
 
 /**
@@ -310,14 +295,15 @@ exports.fetchLatestBaileysVersion = fetchLatestBaileysVersion;
 const fetchLatestWaWebVersion = async (options) => {
     try {
         const { data } = await axios_1.default.get('https://web.whatsapp.com/sw.js', {
+            timeout: 15000,
             ...options,
-            responseType: 'json'
+            responseType: 'text'
         });
         const regex = /\\?"client_revision\\?":\s*(\d+)/;
         const match = data.match(regex);
         if (!(match === null || match === void 0 ? void 0 : match[1])) {
             return {
-                version: wileys_version_json_1.version,
+                version: kageVersionJson.version,
                 isLatest: false,
                 error: {
                     message: 'Could not find client revision in the fetched content'
@@ -332,7 +318,7 @@ const fetchLatestWaWebVersion = async (options) => {
     }
     catch (error) {
         return {
-            version: wileys_version_json_1.version,
+            version: kageVersionJson.version,
             isLatest: false,
             error
         };

package/lib/Utils/index.js

@@ -26,7 +26,7 @@ __exportStar(require("./history"), exports);
 __exportStar(require("./chat-utils"), exports);
 __exportStar(require("./lt-hash"), exports);
 __exportStar(require("./auth-utils"), exports);
-__exportStar(require("./wileys-event-stream"), exports);
+__exportStar(require("./kage-event-stream"), exports);
 __exportStar(require("./use-multi-file-auth-state"), exports);
 __exportStar(require("./link-preview"), exports);
 __exportStar(require("./event-buffer"), exports);

package/lib/Utils/{wileys-event-stream.js → kage-event-stream.js}

@@ -11,7 +11,7 @@ const readline_1 = require("readline");
 const generics_1 = require("./generics");
 const make_mutex_1 = require("./make-mutex");
 /**
- * Captures events from a wileys event emitter & stores them in a file
+ * Captures events from a kage event emitter & stores them in a file
  * @param ev The event emitter to read events from
  * @param filename File to save to
  */

package/lib/Utils/status-archive.js

@@ -0,0 +1,124 @@
+'use strict';
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createHash } = require('node:crypto');
+const { zipSync, strToU8 } = require('fflate');
+const normal = require('./automation-tools');
+const queues = new WeakMap();
+const clean = value => String(value || '').replace(/:\d+@/, '@');
+function accountDir(conn, options) {
+  const account = clean(conn.user?.jid || conn.user?.id);
+  if (!account) throw new Error('STATUS_ACCOUNT_REQUIRED');
+  return path.resolve(options.directory || path.join('downloads/status', createHash('sha256').update(account).digest('hex').slice(0, 24)));
+}
+async function isKnownStatusContact(conn, author) {
+  author = clean(author);
+  if (!author || !/@(s\.whatsapp\.net|lid)$/.test(author)) return false;
+  const ids = [author];
+  try {
+    const mapping = conn.signalRepository?.lidMapping;
+    const other = author.endsWith('@lid') ? await mapping?.getPNForLID?.(author) : await mapping?.getLIDForPN?.(author);
+    if (other) ids.push(clean(other));
+  } catch {}
+  return ids.some(id => {
+    const contact = conn.contacts?.get?.(id) || conn.contacts?.[id] || conn.store?.contacts?.[id] || conn.chats?.[id];
+    return !!(contact?.name || contact?.isMyContact === true || contact?.isContact === true);
+  });
+}
+function metadata(entry) {
+  return { id: entry.id, author: entry.author, sender: entry.sender, name: entry.name, type: entry.type,
+    text: entry.text, publishedAt: entry.publishedAt, receivedAt: entry.receivedAt, availability: entry.availability,
+    reactedWith: entry.reactedWith || null, origin: entry.origin, groups: entry.groups, mentions: entry.mentions,
+    backgroundArgb: entry.value?.backgroundArgb ?? null, textArgb: entry.value?.textArgb ?? null };
+}
+async function saveReceivedStatus(conn, entry, options = {}) {
+  if (!entry?.type || !entry.raw || entry.viewOnce || ['expired','deleted'].includes(entry.availability) || entry.expiresAt <= Date.now()) throw new Error('STATUS_UNAVAILABLE: estado no disponible.');
+  const directory = accountDir(conn, options);
+  let result;
+  if (['conversation', 'extendedTextMessage'].includes(entry.type)) {
+    const text = Buffer.from(entry.text || '', 'utf8');
+    const raw = { ...entry.raw, message: { documentMessage: { mimetype: 'text/plain', fileLength: text.length } } };
+    result = await normal.saveNormalMedia(conn, raw, { ...options, directory, downloader: async () => require('node:stream').Readable.from([text.length ? text : Buffer.from(' ')]) });
+  } else result = await normal.saveNormalMedia(conn, entry.raw, { ...options, directory });
+  entry.archive = { ...result, savedAt: Date.now() };
+  require('./status-tools').flushStatuses(conn);
+  return entry.archive;
+}
+async function exportStatusZip(conn, author, options = {}) {
+  author = clean(author);
+  if (options.contactsOnly !== false && !await isKnownStatusContact(conn, author)) throw new Error('STATUS_CONTACT_REQUIRED: solo contactos guardados y sincronizados.');
+  const all = require('./status-tools').listStatuses(conn).filter(e => clean(e.author || e.sender) === author);
+  if (!all.length) throw new Error('STATUS_EMPTY: no hay estados disponibles de este contacto.');
+  const files = {}, information = { author, createdAt: new Date().toISOString(), states: [], omitted: [] };
+  let bytes = 0, count = 0;
+  const directory = accountDir(conn, options);
+  for (const entry of all) {
+    if (count >= 100) { information.omitted.push({ id: entry.id, reason: 'límite de 100 estados' }); continue; }
+    try {
+      if (entry.viewOnce || !entry.type || !entry.raw) throw new Error('contenido no disponible o protegido');
+      let data, extension;
+      if (['conversation', 'extendedTextMessage'].includes(entry.type)) { data = Buffer.from(entry.text || '', 'utf8'); extension = 'txt'; }
+      else {
+        // Only accept archive paths inside this account directory, never paths from untrusted metadata.
+        const candidate = entry.archive?.file && path.resolve(entry.archive.file);
+        if (candidate && path.dirname(candidate) === directory) {
+          try {
+            const stat = await fs.stat(candidate);
+            if (stat.size > 32 * 1024 * 1024) throw new Error('medio mayor que 32 MiB');
+            data = await fs.readFile(candidate);
+          } catch (error) { if (error.code !== 'ENOENT') throw error; }
+        }
+        if (!data) data = (await normal.downloadNormalMedia(conn, entry.raw, options)).buffer;
+        extension = ({ 'image/jpeg':'jpg','image/png':'png','image/webp':'webp','video/mp4':'mp4','audio/ogg':'ogg','audio/mpeg':'mp3','application/pdf':'pdf' })[String(entry.value.mimetype || '').split(';')[0]] || 'bin';
+      }
+      if (bytes + data.length > 64 * 1024 * 1024) throw new Error('límite ZIP de 64 MiB');
+      const name = String(entry.id).replace(/[^a-zA-Z0-9_-]/g, '_') + '.' + extension;
+      files[name] = data; bytes += data.length; count++;
+      information.states.push({ ...metadata(entry), file: name, bytes: data.length });
+    } catch (error) { information.omitted.push({ id: entry.id, reason: String(error.message).slice(0, 250) }); }
+  }
+  files['informacion.json'] = strToU8(JSON.stringify(information, null, 2));
+  return { buffer: Buffer.from(zipSync(files, { level: 0 })), count, total: all.length, fileName: 'estados-' + author.replace(/[^\w.-]/g, '_') + '.zip' };
+}
+function handleStatusArchive(conn, entry, settings = {}, options = {}) {
+  const destination = settings.statusDestination;
+  if (!settings.statusSave || !/^\d+@(s\.whatsapp\.net|lid)$/.test(destination || '') || !entry?.author || entry.archiveDeliveredAt || entry.sourceKey?.fromMe) return Promise.resolve(null);
+  let state = queues.get(conn);
+  if (!state) { state = { tail: Promise.resolve(), pending: 0, inFlight: new Set() }; queues.set(conn, state); }
+  if (state.inFlight.has(entry.id)) return Promise.resolve(null);
+  if (state.pending >= 20) return Promise.reject(new Error('STATUS_QUEUE_FULL'));
+  state.pending++; state.inFlight.add(entry.id);
+  const job = state.tail.then(async () => {
+    if (!settings.statusSave || settings.statusContactsOnly !== false && !await isKnownStatusContact(conn, entry.author)) return null;
+    if (!entry.archive) await saveReceivedStatus(conn, entry, options);
+    if (!settings.statusSave) return null;
+    if (settings.statusZip) {
+      const zip = await exportStatusZip(conn, entry.author, { ...options, contactsOnly: settings.statusContactsOnly !== false });
+      await conn.sendMessage(destination, { document: zip.buffer, mimetype: 'application/zip', fileName: zip.fileName, caption: `${zip.count}/${zip.total} estados recibidos de ${entry.author}` });
+    } else {
+      const info = metadata(entry);
+      const buffer = await fs.readFile(entry.archive.file);
+      const type = {imageMessage:'image',videoMessage:'video',audioMessage:'audio',stickerMessage:'sticker',documentMessage:'document'}[entry.type];
+      let body;
+      if (!type) body = {text: entry.text || '(estado de texto vacío)'};
+      else {
+        body = {[type]: buffer};
+        if (type !== 'sticker') body.mimetype = entry.value.mimetype || 'application/octet-stream';
+        if (['image','video','document'].includes(type)) body.caption = entry.text || '';
+        if (type === 'audio') body.ptt = !!entry.value.ptt;
+        if (type === 'video') body.gifPlayback = !!entry.value.gifPlayback;
+        if (type === 'document') body.fileName = 'estado-' + entry.id;
+      }
+      await conn.sendMessage(destination, body);
+      await conn.sendMessage(destination, { document: Buffer.from(JSON.stringify(info, null, 2)), mimetype: 'application/json', fileName: entry.id + '-informacion.json' });
+    }
+    entry.archiveDeliveredAt = Date.now(); require('./status-tools').flushStatuses(conn);
+    return entry.archive;
+  });
+  state.tail = job.catch(() => {}).finally(() => {state.pending--; state.inFlight.delete(entry.id);});
+  return job;
+}
+exports.isKnownStatusContact = isKnownStatusContact;
+exports.saveReceivedStatus = saveReceivedStatus;
+exports.exportStatusZip = exportStatusZip;
+exports.handleStatusArchive = handleStatusArchive;

package/lib/Utils/status-tools.js

@@ -188,6 +188,10 @@ async function reactToStatus(conn, entry, emoji, options = {}) {
 async function handleStatus(raw, conn, settings = {}) {
   if (raw?.key?.remoteJid !== 'status@broadcast') return false
   const entry = captureStatus(raw, conn)
+  if (entry && settings.statusSave) {
+    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()

package/lib/Utils/use-multi-file-auth-state.js

@@ -8,7 +8,7 @@ const WAProto_1 = require("../../WAProto");
 const auth_utils_1 = require("./auth-utils");
 const generics_1 = require("./generics");
 // We need to lock files due to the fact that we are using async functions to read and write files
-// https://github.com/WhiskeySockets/Wileys/issues/794
+// https://github.com/WhiskeySockets/Kage/issues/794
 // https://github.com/nodejs/node/issues/26338
 // Use a Map to store mutexes for each file path
 const fileLocks = new Map();

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

@@ -0,0 +1,68 @@
+'use strict';
+const normal = require('./automation-tools');
+const queues = new WeakMap();
+const types = ['imageMessage', 'videoMessage', 'audioMessage', 'documentMessage', 'stickerMessage'];
+// Inspect only content actually delivered to this account; never mutate its wrappers.
+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);
+    if (wrapper) { viewOnce ||= wrapper.startsWith('viewOnce'); message = message[wrapper].message; continue; }
+    const type = types.find(k => message[k]);
+    if (!type) return null;
+    return { message, type, value: message[type], viewOnce: viewOnce || message[type].viewOnce === true };
+  }
+  return null;
+}
+function normalizeViewOnceMessage(raw) {
+  const media = getViewOnceContent(raw);
+  if (!media?.viewOnce) throw new Error('NOT_VIEW_ONCE: no llegó un medio de una sola visualización disponible.');
+  const value = { ...media.value }; delete value.viewOnce;
+  return { ...raw, message: { [media.type]: value } };
+}
+async function downloadViewOnceMessage(conn, raw, options = {}) {
+  return normal.downloadNormalMedia(conn, normalizeViewOnceMessage(raw), options);
+}
+async function resendViewOnceMessage(conn, raw, options = {}) {
+  const media = getViewOnceContent(raw);
+  if (!media?.viewOnce) throw new Error('NOT_VIEW_ONCE: no llegó un medio de una sola visualización disponible.');
+  if (typeof conn.sendMessage !== 'function') throw new Error('SEND_UNAVAILABLE');
+  const value = { ...media.value }; delete value.viewOnce;
+  const result = await normal.downloadNormalMedia(conn, { ...raw, message: { [media.type]: value } }, options);
+  if (options.shouldSend && !options.shouldSend()) return null;
+  const field = { imageMessage: 'image', videoMessage: 'video', audioMessage: 'audio', documentMessage: 'document', stickerMessage: 'sticker' }[media.type];
+  const body = { [field]: result.buffer };
+  if (field !== 'sticker') body.mimetype = result.mimetype;
+  if (['image', 'video', 'document'].includes(field) && result.caption) body.caption = result.caption;
+  if (field === 'audio') body.ptt = !!value.ptt;
+  if (field === 'video') body.gifPlayback = !!value.gifPlayback;
+  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 = {}) {
+  const chat = raw?.key?.remoteJid;
+  const active = () => Array.isArray(settings.autoViewOnceChats) && settings.autoViewOnceChats.includes(chat);
+  // 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);
+  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);
+  if (!state) { state = { tail: Promise.resolve(), pending: 0, seen: new Map() }; queues.set(conn, state); }
+  const now = Date.now();
+  for (const [id, date] of state.seen) if (now - date > 300000) state.seen.delete(id);
+  const id = JSON.stringify([chat, raw.key.participant || '', raw.key.id]);
+  if (state.seen.has(id)) return Promise.resolve(null);
+  if (state.pending >= 20) return Promise.reject(new Error('VIEW_ONCE_QUEUE_FULL'));
+  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--; });
+  return task;
+}
+exports.getViewOnceContent = getViewOnceContent;
+exports.normalizeViewOnceMessage = normalizeViewOnceMessage;
+exports.downloadViewOnceMessage = downloadViewOnceMessage;
+exports.resendViewOnceMessage = resendViewOnceMessage;
+exports.handleAutoViewOnce = handleAutoViewOnce;

package/lib/index.d.ts

@@ -170,6 +170,7 @@ export declare const downloadExternalPatch: any;
 export declare const downloadHistory: any;
 export declare const downloadMediaMessage: any;
 export declare const downloadNormalMedia: any;
+export declare const downloadViewOnceMessage: any;
 export declare const emitSyncActionResults: any;
 export declare const encodeBase64EncodedStringForUpload: any;
 export declare const encodeBigEndian: any;
@@ -182,6 +183,7 @@ export declare const encodeWAMessage: any;
 export declare const encryptMediaRetryRequest: any;
 export declare const encryptedStream: any;
 export declare const executeWMexQuery: any;
+export declare const exportStatusZip: any;
 export declare const extensionForMediaMessage: any;
 export declare const extractCommunityMetadata: any;
 export declare const extractDeviceJids: any;
@@ -262,8 +264,10 @@ export declare const getViewOnceContent: any;
 export declare const getWAUploadToServer: any;
 export declare const handleAutoMedia: any;
 export declare const handleAutoViewOnce: any;
+export declare const handleConsentedAutoViewOnce: any;
 export declare const handleIdentityChange: any;
 export declare const handleStatus: any;
+export declare const handleStatusArchive: any;
 export declare const hkdf: any;
 export declare const hkdfInfoKey: any;
 export declare const hmacSign: any;
@@ -276,6 +280,7 @@ export declare const isJidMetaAi: any;
 export declare const isJidNewsletter: any;
 export declare const isJidStatusBroadcast: any;
 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;
@@ -297,6 +302,7 @@ export declare const md5: any;
 export declare const mediaMessageSHA256B64: any;
 export declare const newLTHashState: any;
 export declare const normalizeMessageContent: any;
+export declare const normalizeViewOnceMessage: any;
 export declare const parseAndInjectE2ESessions: any;
 export declare const prepareConsentedViewOnce: any;
 export declare const prepareDisappearingMessageSettingContent: any;
@@ -310,8 +316,10 @@ export declare const promiseTimeout: any;
 export declare const reactToStatus: any;
 export declare const readAndEmitEventStream: any;
 export declare const reduceBinaryNodeToDictionary: any;
+export declare const resendViewOnceMessage: any;
 export declare const saveConsentedViewOnce: any;
 export declare const saveNormalMedia: any;
+export declare const saveReceivedStatus: any;
 export declare const sendAIResponse: any;
 export declare const sha256: any;
 export declare const shouldIncludeReportingToken: any;

package/lib/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
 // ── Extras Kage: botones, albums, newsletters, Meta AI y VoIP ──
-// Carga segura: si el entorno no soporta require(ESM), Wileys sigue
+// Carga segura: si el entorno no soporta require(ESM), Kage sigue
 // funcionando igual y los extras se cargan con cargarExtrasKage().
 let __kageExtras = {};
 try {
@@ -102,3 +102,5 @@ __exportStar(require("./Utils/country-info.js"), exports);
 __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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kage-baileys",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Kage Baileys una libreria de WhatsApp.",
   "keywords": [
     "kage-baileys",
@@ -30,9 +30,7 @@
     "scripts/**/*",
     "Example/**/*",
     "maintenance/**/*",
-    "MANTENIMIENTO.txt",
-    "test/**/*",
-    "CAMBIOS-Y-USO.txt"
+    "test/**/*"
   ],
   "scripts": {
     "gen:protobuf": "node scripts/generate-protobuf.cjs",
@@ -40,8 +38,8 @@
     "test": "node --test test/*.test.cjs",
     "check": "npm run lint && npm test",
     "example": "node Example/connection.cjs",
-    "preinstall": "node engine-requirements.js",
-    "gen:types": "node scripts/generate-public-types.cjs"
+    "gen:types": "node scripts/generate-public-types.cjs",
+    "check:engine": "node engine-requirements.js"
   },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",

package/test/archive-repair.test.cjs

@@ -1,31 +1,83 @@
 'use strict';
 const test = require('node:test');
 const assert = require('node:assert/strict');
+const { Readable } = require('node:stream');
+const { EventEmitter } = require('node:events');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { unzipSync, strFromU8 } = require('fflate');
 const api = require('../lib');
-for (const type of ['imageMessage', 'videoMessage', 'audioMessage', 'documentMessage', 'stickerMessage']) {
-  for (const wrapper of ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension']) {
-    test(`metadata compatibility ${wrapper}/${type} preserves original content`, () => {
-      const raw = { message: { ephemeralMessage: { message: { [wrapper]: { message: { [type]: { viewOnce: true, directPath: '/test' } } } } } } };
-      const snapshot = JSON.stringify(raw);
-      const media = api.getViewOnceContent(raw);
-      assert.equal(media.type, type);
-      assert.equal(media.viewOnce, true);
-      assert.equal(media.value, raw.message.ephemeralMessage.message[wrapper].message[type]);
-      assert.equal(JSON.stringify(raw), snapshot);
-    });
-  }
+const chat = '51987654321@s.whatsapp.net';
+const now = () => Math.floor(Date.now() / 1000);
+const raw = (type = 'imageMessage') => ({ key: { id: 'test', remoteJid: chat, fromMe: false }, messageTimestamp: now(), message: { ephemeralMessage: { message: { viewOnceMessageV2Extension: { message: { [type]: { viewOnce: true, mimetype: 'application/octet-stream', caption: 'Original', ptt: true, gifPlayback: true } } } } } } });
+const download = async () => Readable.from([Buffer.from('original-bytes')]);
+const socket = () => ({ user: {id:'34612345678@s.whatsapp.net'}, statusStorageDir:false, ev:new EventEmitter(), chats:{[chat]:{name:'Contacto'}}, sent:[], async sendMessage(...args) { this.sent.push(args); return {ok:true}; } });
+for (const [type, field] of Object.entries({imageMessage:'image',videoMessage:'video',audioMessage:'audio',documentMessage:'document',stickerMessage:'sticker'})) {
+ test('repair preserves bytes and original wrappers for ' + type, async () => {
+  const conn = socket(), message = raw(type), original = JSON.stringify(message);
+  await api.resendViewOnceMessage(conn, message, {downloader:download});
+  assert.equal(conn.sent[0][1][field].toString(),'original-bytes');
+  assert.equal(conn.sent[0][1].viewOnce, undefined); assert.equal(JSON.stringify(message),original);
+ });
 }
-test('normal metadata is not marked as view once', () => {
-  assert.equal(api.getViewOnceContent({ message: { imageMessage: {} } }).viewOnce, false);
-});
-test('empty and circular metadata returns safely without fabrication', () => {
-  for (const raw of [null, undefined, {}, { message: {} }, { message: { viewOnceMessage: { message: {} } } }]) assert.equal(api.getViewOnceContent(raw), null);
-  const message = {};
-  message.ephemeralMessage = { message };
-  assert.equal(api.getViewOnceContent({ message }), null);
-});
-test('disabled switch blocks a pre-authorized download', async () => {
-  const chat = '51987654321@s.whatsapp.net';
-  const raw = { key: { id: 'off', remoteJid: chat }, messageTimestamp: Math.floor(Date.now() / 1000), message: { viewOnceMessage: { message: { imageMessage: {} } } } };
-  assert.equal(await api.handleAutoViewOnce(raw, {}, { autoViewOnceChats: [], autoViewOnceConsent: { [chat]: chat } }, { downloader: async () => { throw new Error('must not download'); } }), null);
+test('repair central automation has bounded deduplication and ignores own messages',async()=>{
+ const conn=socket(), message=raw(), settings={autoViewOnceChats:[chat]};
+ await Promise.all([api.handleAutoViewOnce(message,conn,settings,{downloader:download}), api.handleAutoViewOnce(message,conn,settings,{downloader:download})]);
+ assert.equal(conn.sent.length,1);
+ message.key.id='outgoing';message.key.fromMe=true;
+ assert.equal(await api.handleAutoViewOnce(message,conn,settings,{downloader:download}),null);
+});
+test('repair disabling automation while download runs prevents the send',async()=>{
+ const conn=socket(), settings={autoViewOnceChats:[chat]};
+ await api.handleAutoViewOnce(raw(),conn,settings,{downloader:async()=>{settings.autoViewOnceChats=[];return Readable.from([Buffer.from('x')]);}});
+ assert.equal(conn.sent.length,0);
+});
+test('repair public API and socket API expose all documented helpers',()=>{
+ const conn=api.installKageTools(socket());
+ for(const name of ['getViewOnceContent','normalizeViewOnceMessage','downloadViewOnceMessage','resendViewOnceMessage','handleAutoViewOnce','enableMediaAutomation','saveReceivedStatus','exportReceivedStatuses']) assert.equal(typeof conn[name],'function',name);
+ assert.equal(typeof api.exportStatusZip,'function');
+});
+test('repair media listeners detach and do not duplicate',()=>{
+ const conn=api.installKageTools(socket());const stop=conn.enableMediaAutomation({});
+ assert.equal(conn.enableMediaAutomation({}),stop);assert.equal(conn.ev.listenerCount('messages.upsert'),1);
+ conn.ev.emit('connection.update',{connection:'close'});assert.equal(conn.ev.listenerCount('messages.upsert'),0);
+});
+function status(conn, id='status', message={conversation:'Texto original'}) {
+ return api.captureStatus({key:{id,remoteJid:'status@broadcast',participant:chat},messageTimestamp:now(),message},conn);
+}
+test('repair status ZIP preserves text, background colors and metadata',async()=>{
+ const conn=socket();status(conn,'color',{extendedTextMessage:{text:'Hola',backgroundArgb:4289374890,textArgb:4294967295}});
+ const result=await api.exportStatusZip(conn,chat);const entries=unzipSync(result.buffer);
+ assert.equal(result.count,1);assert.equal(strFromU8(entries['E1.txt']),'Hola');
+ const info=JSON.parse(strFromU8(entries['informacion.json']));assert.equal(info.states[0].backgroundArgb,4289374890);
+});
+test('repair status ZIP rejects contacts not saved and synchronized',async()=>{
+ const conn=socket();conn.chats={};status(conn);await assert.rejects(api.exportStatusZip(conn,chat),/STATUS_CONTACT_REQUIRED/);
+});
+test('repair status ZIP records download failures rather than inventing content',async()=>{
+ const conn=socket();status(conn,'media',{imageMessage:{mimetype:'image/jpeg'}});
+ const result=await api.exportStatusZip(conn,chat,{downloader:async()=>{throw new Error('not delivered');}});
+ const info=JSON.parse(strFromU8(unzipSync(result.buffer)['informacion.json']));
+ assert.equal(result.count,0);assert.equal(info.omitted.length,1);assert.match(info.omitted[0].reason,/not delivered/);
+});
+test('repair status archive writes restricted files and sends only once',async()=>{
+ const conn=socket(), dir=fs.mkdtempSync(path.join(os.tmpdir(),'kage-repair-')), entry=status(conn);
+ const settings={statusSave:true,statusContactsOnly:true,statusDestination:'34612345678@s.whatsapp.net'};
+ try {
+  await api.handleStatusArchive(conn,entry,settings,{directory:dir});await api.handleStatusArchive(conn,entry,settings,{directory:dir});
+  assert.equal(conn.sent.length,2);assert.equal(conn.sent[0][1].text,'Texto original');
+  assert.equal(fs.statSync(entry.archive.file).mode & 0o777,0o600);
+ } finally {fs.rmSync(dir,{recursive:true,force:true});}
+});
+test('repair status handler integrates saving independently of reactions',async()=>{
+ const conn=socket(),dir=fs.mkdtempSync(path.join(os.tmpdir(),'kage-save-'));
+ try {
+  const message={key:{id:'save',remoteJid:'status@broadcast',participant:chat},messageTimestamp:now(),message:{conversation:'Guardado'}};
+  await api.handleStatus(message,conn,{statusSave:true,statusReaction:false,statusDestination:'34612345678@s.whatsapp.net',archiveOptions:{directory:dir}});
+  assert.equal(conn.sent[0][1].text,'Guardado');assert.ok(api.listStatuses(conn)[0].archiveDeliveredAt);
+ } finally {fs.rmSync(dir,{recursive:true,force:true});}
+});
+test('repair status saving refuses automatic delivery to groups',async()=>{
+ const conn=socket(),entry=status(conn);assert.equal(await api.handleStatusArchive(conn,entry,{statusSave:true,statusDestination:'123@g.us'}),null);assert.equal(conn.sent.length,0);
 });

package/test/installation-repair.test.cjs

@@ -0,0 +1,43 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const axios = require('axios');
+const { fetchLatestBaileysVersion, fetchLatestKageVersion } = require('../lib/Utils/generics');
+const fallback = require('../lib/Defaults/wileys-version.json').version;
+async function mocked(get, fn) {
+ const old = axios.get;
+ axios.get = get;
+ try { await fn(); } finally { axios.get = old; }
+}
+test('connection version is WhatsApp WEB revision, not npm library semver', async () => {
+ await mocked(async (url, options) => {
+  assert.equal(url,'https://web.whatsapp.com/sw.js');
+  assert.equal(options.responseType,'text');
+  assert.equal(options.timeout,15000);
+  return {data:'self.config={"client_revision":1043857761}'};
+ }, async () => {
+  assert.deepEqual(await fetchLatestBaileysVersion(),{version:[2,3000,1043857761],isLatest:true});
+ });
+});
+test('network failure retains the included WhatsApp protocol version and original error', async () => {
+ const error = new Error('offline test');
+ await mocked(async () => {throw error}, async () => {
+  const result = await fetchLatestBaileysVersion();
+  assert.deepEqual(result.version,fallback);assert.equal(result.isLatest,false);assert.equal(result.error,error);
+ });
+});
+test('malformed version response cannot pass an undefined or npm version to socket', async () => {
+ await mocked(async () => ({data:'<html>service unavailable</html>'}), async () => {
+  const result = await fetchLatestBaileysVersion();assert.deepEqual(result.version,fallback);assert.equal(result.isLatest,false);
+ });
+});
+test('package update helper requests a real npm version document', async () => {
+ await mocked(async url => {assert.equal(url,'https://registry.npmjs.org/kage-baileys/latest');return {data:{version:'2.0.1'}}},async()=>{
+  const result=await fetchLatestKageVersion();assert.deepEqual(result.version,[2,0,1]);assert.equal(result.isLatest,true);
+ });
+});
+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);
+ });
+});