kage-baileys 3.0.6 → 3.2.3

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/resilience-binary.test.cjs

@@ -0,0 +1,69 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { deflateSync } = require('node:zlib');
+const { randomBytes } = require('node:crypto');
+const { decodeBinaryNode, decodeDecompressedBinaryNode, decompressingIfRequired } = require('../lib/WABinary/decode');
+const { encodeBinaryNode } = require('../lib/WABinary/encode');
+const constants = require('../lib/WABinary/constants');
+const { inspectMessage } = require('../lib/Utils/message-inspector');
+const { TAGS } = constants;
+
+test('round trip de Unicode y contenido binario sin alteración', async () => {
+  const node = { tag:'message', attrs:{ id:'日本語-😺', to:'51900000001@s.whatsapp.net' }, content:[{tag:'body',attrs:{},content:Buffer.from([0,255,128,1,2])}] };
+  const decoded = await decodeBinaryNode(encodeBinaryNode(node));
+  assert.deepEqual(decoded,node);
+});
+test('paquetes vacíos, corruptos y truncados se rechazan', async () => {
+  await assert.rejects(decodeBinaryNode(Buffer.alloc(0)),/BINARY_SIZE_LIMIT/);
+  await assert.rejects(decodeBinaryNode(Buffer.from([2,255,0,13])));
+  const buffer = encodeBinaryNode({ tag:'message',attrs:{id:'test'},content:Buffer.from('test') });
+  for (let i=1;i<buffer.length;i++) await assert.rejects(decodeBinaryNode(buffer.subarray(0,i)));
+});
+test('inflado tiene límite contra paquetes comprimidos desproporcionados', async () => {
+  const compressed = deflateSync(Buffer.alloc(33*1024*1024));
+  await assert.rejects(decompressingIfRequired(Buffer.concat([Buffer.from([2]),compressed])), /larger|limit|length|buffer/i);
+});
+test('BINARY_32 no acepta longitudes negativas por desbordamiento de signo', () => {
+  const head = [TAGS.LIST_8,2,TAGS.BINARY_8,1,120,TAGS.BINARY_32,255,255,255,255];
+  assert.throws(() => decodeDecompressedBinaryNode(Buffer.from(head),constants),/end of stream/);
+});
+test('árbol binario profundo se detiene antes de agotar la pila', async () => {
+  const parts = [Buffer.from([0])];
+  for(let i=0;i<80;i++) parts.push(Buffer.from([TAGS.LIST_8,2,TAGS.BINARY_8,1,120,TAGS.LIST_8,1]));
+  parts.push(Buffer.from([TAGS.LIST_8,1,TAGS.BINARY_8,1,120]));
+  await assert.rejects(decodeBinaryNode(Buffer.concat(parts)),/BINARY_COMPLEXITY_LIMIT/);
+});
+test('pares JID recursivos se detienen antes de agotar la pila', async () => {
+  const parts = [Buffer.from([0,TAGS.LIST_8,1])];
+  for(let i=0;i<80;i++) parts.push(Buffer.from([TAGS.JID_PAIR]));
+  parts.push(Buffer.from([TAGS.BINARY_8,1,120]));
+  await assert.rejects(decodeBinaryNode(Buffer.concat(parts)),/BINARY_STRING_DEPTH_LIMIT/);
+});
+test('claves especiales de atributos no modifican el prototipo', async () => {
+  const attrs = JSON.parse('{"__proto__":"literal","id":"test"}');
+  const decoded = await decodeBinaryNode(encodeBinaryNode({ tag:'message',attrs }));
+  assert.equal(Object.hasOwn(decoded.attrs,'__proto__'),true);
+  assert.equal(decoded.attrs.__proto__,'literal'); assert.equal({}.polluted,undefined);
+});
+test('1000 entradas binarias aleatorias terminan sin bloquear', async () => {
+  let rejected = 0;
+  for(let i=0;i<1000;i++) {
+    const raw = Buffer.concat([Buffer.from([0]),randomBytes(1+(i%256))]);
+    try { await decodeBinaryNode(raw) } catch { rejected++ }
+  }
+  assert.ok(rejected>900);
+});
+test('inspector tolera null, menciones inválidas y valores numéricos corruptos', () => {
+  assert.equal(inspectMessage(null).type,'unknown');
+  const info = inspectMessage({ key:{remoteJid:'51900000001@s.whatsapp.net',id:'x'}, messageTimestamp:{toNumber(){throw new Error('bad')}},message:{extendedTextMessage:{text:'😺',contextInfo:{mentionedJid:33}}} });
+  assert.equal(info.timestamp,0); assert.deepEqual(info.mentions,[]); assert.equal(info.type,'extendedTextMessage');
+});
+test('envolturas circulares o nulas no producen recursión ilimitada', () => {
+  const raw = { message:{} }; raw.message.ephemeralMessage = {message:raw.message};
+  assert.equal(inspectMessage(raw).type,'unknown'); assert.equal(inspectMessage({message:{imageMessage:null}}).type,'unknown');
+});
+test('inspector limita menciones sin exponer bytes de medios', () => {
+  const info = inspectMessage({message:{imageMessage:{mediaKey:Buffer.from('private-key'),contextInfo:{mentionedJid:Array.from({length:300},(_,i)=>`${i}@lid`)}}}});
+  assert.equal(info.mentions.length,100); assert.equal(JSON.stringify(info).includes('private-key'),false);
+});

package/test/resilience-transport.test.cjs

@@ -0,0 +1,34 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const vm = require('node:vm');
+const crypto = require('node:crypto');
+function noise() {
+  const sandbox = { exports:{}, Buffer, Uint8Array, ArrayBuffer, DataView, require(name) {
+    if(name==='@hapi/boom') return { Boom:Error };
+    if(name==='../../WAProto') return { proto:{} };
+    if(name==='../Defaults') return { NOISE_MODE:'test',WA_CERT_DETAILS:{SERIAL:0} };
+    if(name==='../WABinary') return {};
+    if(name==='./crypto') return { sha256:data=>crypto.createHash('sha256').update(data).digest() };
+    return require(require('node:path').resolve(__dirname,'../lib/Utils',name));
+  } };
+  vm.runInNewContext(fs.readFileSync(require.resolve('../lib/Utils/noise-handler'),'utf8'),sandbox);
+  const logger = { child(){return this},trace(){} };
+  return sandbox.exports.makeNoiseHandler({ keyPair:{ private:Buffer.alloc(32),public:Buffer.alloc(32) },NOISE_HEADER:Buffer.alloc(0),logger });
+}
+test('framing acepta fragmentación normal y múltiples frames', async()=>{
+  const handler = noise(), received=[];
+  await handler.decodeFrame(Buffer.from([0,0]),frame=>received.push(frame));
+  await handler.decodeFrame(Buffer.from([3,97,98,99,0,0,1,100]),frame=>received.push(frame));
+  assert.deepEqual(received.map(x=>x.toString()),['abc','d']);
+});
+test('framing rechaza tamaño cero y no deja bytes acumulándose', async()=>{
+  const handler = noise(), received=[];
+  await assert.rejects(handler.decodeFrame(Buffer.from([0,0,0]),()=>{}),/NOISE_EMPTY_FRAME/);
+  await handler.decodeFrame(Buffer.from([0,0,1,97]),frame=>received.push(frame));
+  assert.equal(received[0].toString(),'a');
+});
+test('framing rechaza acumulación superior al límite', async()=>{
+  await assert.rejects(noise().decodeFrame(Buffer.alloc(33*1024*1024),()=>{}),/NOISE_BUFFER_LIMIT/);
+});

package/test/types.test.ts

@@ -0,0 +1,5 @@
+import makeWASocket, {proto, say, generateWAMessageContent, useMultiFileAuthState} from 'kage-baileys';
+const message: proto.Message.$Properties = {conversation:'Prueba'};
+const encoded: Uint8Array = proto.Message.encode(message).finish();
+void encoded; void makeWASocket; void useMultiFileAuthState; void generateWAMessageContent;
+say('kage baileys',{font:'simple',gradient:['red','magenta']});

package/test/upgrade.test.cjs

@@ -0,0 +1,104 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const crypto = require('node:crypto');
+const { createRequire } = require('node:module');
+const { EventEmitter } = require('node:events');
+const api = require('../lib');
+const logger = require('pino')({level:'silent'});
+const tick = () => new Promise(resolve => setImmediate(resolve));
+
+test('API pública disponible en CJS y ESM en un único paquete', async()=>{
+ const esm=await import('../lib/index.mjs');for(const key of Object.keys(api))if(key!=='__esModule')assert.ok(key in esm,key);
+ assert.equal(esm.makeWASocket,api.makeWASocket);assert.equal(fs.existsSync(path.join(__dirname,'../vendor')),false);
+});
+
+test('scoped event leases cannot flush another operation or a later generation', () => {
+  const ev = api.makeEventBuffer(logger), received=[];
+  ev.on('contacts.upsert', list=>received.push(...list));
+  const release1 = ev.buffer(), release2 = ev.buffer();
+  ev.emit('contacts.upsert', [{id:'1@s.whatsapp.net'}]);
+  release1(); assert.equal(ev.isBuffering(),true); release1(); assert.equal(ev.isBuffering(),true);
+  release2(); assert.equal(received.length,1);
+  const old = ev.buffer(); ev.flush(true); const current=ev.buffer();
+  old(); assert.equal(ev.isBuffering(),true); current(); assert.equal(ev.isBuffering(),false);
+});
+
+test('reentrant events emitted while flushing are not discarded', () => {
+  const ev=api.makeEventBuffer(logger), ids=[];
+  ev.on('contacts.upsert', list=>{ids.push(...list.map(x=>x.id));if(ids.length===1)ev.emit('contacts.upsert',[{id:'second'}]);});
+  ev.buffer(); ev.emit('contacts.upsert',[{id:'first'}]);ev.flush();
+  assert.deepEqual(ids,['first','second']);
+});
+
+function mockChats({history=true, processor=async()=>{}}={}) {
+  const timers=[];
+  const ev=api.makeEventBuffer(logger), ws=new EventEmitter();
+  const sock={ev,ws,authState:{creds:{me:{id:'51900000000@s.whatsapp.net'},accountSettings:{}},keys:{get:async()=>({}),set:async()=>{}}},query:async()=>({tag:'iq',attrs:{},content:[]}),sendNode:async()=>{},generateMessageTag:()=> 'tag',signalRepository:{},onUnexpectedError:()=>{}};
+  const filename=require.resolve('../lib/Socket/chats');const nativeRequire=createRequire(filename);
+  const sandbox={exports:{},Buffer,console,setTimeout(fn,ms){const t={fn,ms,unref(){}};timers.push(t);return t},clearTimeout(){},require(name){if(name==='./usync')return {makeUSyncSocket:()=>sock};if(name==='../Utils/process-message')return {__esModule:true,default:processor};return nativeRequire(name)}};
+  vm.runInNewContext(fs.readFileSync(filename,'utf8'),sandbox,{filename});
+  const config={...api.DEFAULT_CONNECTION_CONFIG,logger,fireInitQueries:false,markOnlineOnConnect:false,shouldSyncHistoryMessage:()=>history,initialSyncTimeoutMs:1000};
+  const chats=sandbox.exports.makeChatsSocket(config);
+  return {sock,chats,ev,timers};
+}
+
+test('missing app-state key no longer creates an unmatched buffering level', () => {
+  const {ev,timers}=mockChats();let received=0;ev.on('chats.upsert',()=>received++);
+  ev.emit('connection.update',{receivedPendingNotifications:true});
+  ev.emit('chats.upsert',[{id:'123@g.us'}]);assert.equal(received,0);
+  timers.find(t=>t.ms===1000).fn();assert.equal(received,1);assert.equal(ev.isBuffering(),false);
+  ev.emit('connection.update',{connection:'close'});
+});
+
+test('history disabled releases the initial lease even if keys are missing', () => {
+  const {ev}=mockChats({history:false});ev.emit('connection.update',{receivedPendingNotifications:true});
+  assert.equal(ev.isBuffering(),false);ev.emit('connection.update',{connection:'close'});
+});
+
+test('a stalled history download never holds live upserts or their event leases', async () => {
+  let finish;const stalled=new Promise(resolve=>finish=resolve);
+  const {chats,ev,timers}=mockChats({processor:msg=>msg.key.id==='history'?stalled:Promise.resolve()});
+  ev.emit('connection.update',{receivedPendingNotifications:true});
+  const history={key:{remoteJid:'51900000000@s.whatsapp.net',id:'history',fromMe:false},message:{protocolMessage:{historySyncNotification:{syncType:api.proto.HistorySync.HistorySyncType.RECENT}}}};
+  const result=await Promise.race([chats.upsertMessage(history,'append').then(()=>true),new Promise(resolve=>setTimeout(()=>resolve(false),500))]);
+  assert.equal(result,true);
+  const messages=[];ev.on('messages.upsert',event=>messages.push(...event.messages));
+  timers.find(t=>t.ms===1000).fn();
+  await chats.upsertMessage({key:{remoteJid:'51900000001@s.whatsapp.net',id:'live'},message:{conversation:'ping'}},'notify');
+  assert.ok(messages.some(m=>m.key.id==='live'));assert.equal(ev.isBuffering(),false);
+  finish();await tick();ev.emit('connection.update',{connection:'close'});
+});
+
+test('complete socket exposes supplemental methods and closes safely during handshake', async () => {
+  const socket=api.makeWASocket({auth:{creds:api.initAuthCreds(),keys:{get:async()=>({}),set:async()=>{}}},logger,waWebSocketUrl:'wss://127.0.0.1:1',connectTimeoutMs:1000,fireInitQueries:false,kageTools:{banner:false}});
+  for (const group of require('../maintenance/extension-inventory.json')) for (const key of group.methods) assert.ok(key in socket,key);
+  assert.equal(typeof socket.communityCreate,'function');
+  socket.end(new Error('local test complete'));
+  await new Promise(resolve=>setTimeout(resolve,30));
+});
+
+test('supplemental quick replies use the supplied converter and existing appPatch', async () => {
+  const calls=[];
+  const base={authState:{creds:{}},ev:api.makeEventBuffer(logger),ws:new EventEmitter(),appPatch:async patch=>calls.push(patch),query:async()=>{},chatModify:()=>{throw new Error('older converter must not be called')}};
+  const extra=require('../lib/Extensions/chats').attach(base,{...api.DEFAULT_CONNECTION_CONFIG,logger});
+  await extra.addOrEditQuickReply({shortcut:'hola',message:'Hola',timestamp:'123'});
+  await extra.removeQuickReply('123');
+  assert.equal(calls.length,2);assert.equal(calls[0].syncAction.quickReplyAction.shortcut,'hola');assert.equal(calls[1].syncAction.quickReplyAction.deleted,true);
+});
+
+test('supplemental business and community methods use the same query transport', async () => {
+  const calls=[];const base={authState:{creds:{}},query:async node=>{calls.push(node);return {tag:'iq',attrs:{},content:[]}},waUploadToServer:async()=>{},ev:new EventEmitter()};
+  const business=require('../lib/Extensions/business').attach(base,{});
+  await business.updateBussinesProfile({description:'Prueba'});await business.removeCoverPhoto();
+  const community=require('../lib/Extensions/community').attach(base,{});await community.communityQuery('123@g.us','get',[]);
+  assert.equal(calls.length,3);assert.equal(calls[0].attrs.xmlns,'w:biz');assert.equal(calls[2].attrs.xmlns,'w:g2');
+});
+
+test('banner includes requested creator and partner without ANSI in a non-TTY stream', () => {
+  const output=[];api.showKageBanner({stream:{columns:60,isTTY:false,write:text=>output.push(text)}});
+  const text=output.join('');assert.match(text,/Creado por xrljosedv/);assert.match(text,/Socio David Zuniga/);assert.ok(!text.includes('\x1b['));
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": false,
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "test/types.test.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/WAProto/p.html

@@ -1 +0,0 @@
-kage