@roidev/kachina-md 2.1.2 → 2.1.4

package/lib/client/Client.js

@@ -3,7 +3,8 @@ import makeWASocket, {
     useMultiFileAuthState,
     makeCacheableSignalKeyStore,
     fetchLatestBaileysVersion,
-    downloadMediaMessage
+    downloadMediaMessage,
+    Browsers
 } from 'baileys';
 import { Boom } from '@hapi/boom';
 import pino from 'pino';
@@ -109,7 +110,7 @@ export class Client extends EventEmitter {
                 keys: makeCacheableSignalKeyStore(state.keys, this.config.logger)
             },
             logger: this.config.logger,
-            browser: this.config.browser,
+            browser: Browsers.macOS('safari'),
             getMessage: async (key) => {
                 if (this.store) {
                     const msg = await this.store.loadMessage(key.remoteJid, key.id);
@@ -125,67 +126,56 @@ export class Client extends EventEmitter {
 
         this.sock.ev.on('creds.update', saveCreds);
 
-        // Handle pairing code request (must be before connection)
+        // Handle pairing code request (before connection.update listener)
         if (this.config.loginMethod === 'pairing' && !state.creds.registered) {
             if (!this.config.phoneNumber) {
                 throw new Error('Phone number is required for pairing method. Example: { phoneNumber: "628123456789" }');
             }
 
             const phoneNumber = this.config.phoneNumber.replace(/[^0-9]/g, '');
-
             if (phoneNumber.length < 10) {
                 throw new Error('Invalid phone number format. Use country code without +. Example: 628123456789');
             }
 
             console.log('🔐 Initiating pairing code process...');
 
-            // Request pairing code with retry mechanism
-            const requestPairingWithRetry = async () => {
-                const maxRetries = 3;
-                const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
-                for (let attempt = 0; attempt < maxRetries; attempt++) {
-                    try {
-                        // Wait for socket to be ready
-                        await delay(attempt === 0 ? 5000 : 2000);
-
-                        const code = await this.sock.requestPairingCode(phoneNumber);
-                        this.emit('pairing.code', code);
-
-                        // Log to console with formatting
-                        console.log('\n┌─────────────────────────────────────┐');
-                        console.log('│     WhatsApp Pairing Code           │');
-                        console.log('├─────────────────────────────────────┤');
-                        console.log(`│         Code: ${chalk.bgYellowBright.white(code)}               │`);
-                        console.log('└─────────────────────────────────────┘');
-                        console.log('\nSteps to pair:');
-                        console.log('1. Open WhatsApp on your phone');
-                        console.log('2. Go to Settings > Linked Devices');
-                        console.log('3. Tap "Link a Device"');
-                        console.log('4. Enter the code above\n');
-                        console.log('⚠️  Make sure the phone number matches your WhatsApp account');
-
-                        return;
-                    } catch (error) {
-                        const isLastAttempt = attempt === maxRetries - 1;
-                        console.error(`Pairing attempt ${attempt + 1}/${maxRetries} failed:`, error.message);
-
-                        this.emit('pairing.error', error);
-
-                        if (isLastAttempt) {
-                            console.error('❌ Max pairing retries reached. Please try again later.');
-                            throw error; // Re-throw on last attempt
-                        } else {
-                            console.log(`⏳ Retrying in 2 seconds...`);
-                        }
+            const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+            let retryCount = 0;
+            const maxRetries = 3;
+            let pairingSuccess = false;
+
+            while (retryCount < maxRetries && !pairingSuccess) {
+                try {
+                    await delay(3000);
+                    const code = await this.sock.requestPairingCode(phoneNumber);
+                    this.emit('pairing.code', code);
+
+                    console.log('\n┌─────────────────────────────────────┐');
+                    console.log('│     WhatsApp Pairing Code           │');
+                    console.log('├─────────────────────────────────────┤');
+                    console.log(`│         Code: ${chalk.bgYellowBright.white(code)}               │`);
+                    console.log('└─────────────────────────────────────┘');
+                    console.log('\nSteps to pair:');
+                    console.log('1. Open WhatsApp on your phone');
+                    console.log('2. Go to Settings > Linked Devices');
+                    console.log('3. Tap "Link a Device"');
+                    console.log('4. Enter the code above\n');
+
+                    pairingSuccess = true;
+                    break;
+                } catch (err) {
+                    retryCount++;
+                    console.error(`Pairing attempt ${retryCount}/${maxRetries} failed:`, err.message);
+                    this.emit('pairing.error', err);
+
+                    if (retryCount >= maxRetries) {
+                        console.error('❌ Max pairing retries reached. Please try again later.');
+                        throw err;
                     }
-                }
-            };
 
-            // Execute pairing request (non-blocking)
-            requestPairingWithRetry().catch(err => {
-                console.error('Failed to complete pairing process:', err.message);
-            });
+                    await delay(2000);
+                }
+            }
         }
 
         this.sock.ev.on('connection.update', async (update) => {
@@ -233,6 +223,7 @@ export class Client extends EventEmitter {
     async handleConnectionUpdate(update) {
         const { connection, lastDisconnect, qr } = update;
 
+        // Handle QR code for QR login method
         if (qr && this.config.loginMethod === 'qr') {
             qrcode.generate(qr, { small: true });
         }
@@ -253,15 +244,11 @@ export class Client extends EventEmitter {
             this.user = this.sock.user;
             this.emit('ready', this.user);
 
-            // Log success message
             if (this.config.loginMethod === 'pairing') {
                 console.log('\n✓ Successfully connected via pairing code!\n');
             }
         } else if (connection === 'connecting') {
             this.emit('connecting');
-            if (this.config.loginMethod === 'pairing') {
-                console.log('Waiting for pairing code confirmation...');
-            }
         }
     }
 
@@ -480,11 +467,92 @@ export class Client extends EventEmitter {
         });
     }
 
+    /**
+     * Helper function to unwrap view once message from various structures
+     * @private
+     * @param {Object} quotedMessage - The quoted message object
+     * @returns {Object|null} Unwrapped message or null if not view once
+     */
+    _unwrapViewOnceMessage(quotedMessage) {
+        const quotedMsg = quotedMessage?.message;
+        const quotedRaw = quotedMessage?.raw?.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+
+        let innerMsg = null;
+        let isViewOnce = false;
+
+        // Helper to extract from wrapper
+        const extractFromWrapper = (wrapper) => {
+            if (wrapper?.viewOnceMessageV2?.message) {
+                return { msg: wrapper.viewOnceMessageV2.message, isVO: true };
+            }
+            if (wrapper?.viewOnceMessageV2Extension?.message) {
+                return { msg: wrapper.viewOnceMessageV2Extension.message, isVO: true };
+            }
+            if (wrapper?.viewOnceMessage?.message) {
+                return { msg: wrapper.viewOnceMessage.message, isVO: true };
+            }
+            return null;
+        };
+
+        // Try multiple paths to find view once message
+        // Path 1: Direct from quotedRaw
+        if (quotedRaw) {
+            const extracted = extractFromWrapper(quotedRaw);
+            if (extracted) {
+                innerMsg = extracted.msg;
+                isViewOnce = extracted.isVO;
+            } else if (quotedRaw.ephemeralMessage?.message) {
+                const ephExtracted = extractFromWrapper(quotedRaw.ephemeralMessage.message);
+                if (ephExtracted) {
+                    innerMsg = ephExtracted.msg;
+                    isViewOnce = ephExtracted.isVO;
+                }
+            }
+        }
+
+        // Path 2: From quotedMsg
+        if (!innerMsg && quotedMsg) {
+            const extracted = extractFromWrapper(quotedMsg);
+            if (extracted) {
+                innerMsg = extracted.msg;
+                isViewOnce = extracted.isVO;
+            } else if (quotedMsg.ephemeralMessage?.message) {
+                const ephExtracted = extractFromWrapper(quotedMsg.ephemeralMessage.message);
+                if (ephExtracted) {
+                    innerMsg = ephExtracted.msg;
+                    isViewOnce = ephExtracted.isVO;
+                }
+            }
+        }
+
+        // Path 3: Already unwrapped (has viewOnce flag)
+        if (!innerMsg && quotedMsg) {
+            if (quotedMsg.imageMessage?.viewOnce ||
+                quotedMsg.videoMessage?.viewOnce ||
+                quotedMsg.audioMessage?.viewOnce) {
+                innerMsg = quotedMsg;
+                isViewOnce = true;
+            }
+        }
+
+        // Path 4: Check raw message directly
+        if (!innerMsg && quotedRaw) {
+            if (quotedRaw.imageMessage?.viewOnce ||
+                quotedRaw.videoMessage?.viewOnce ||
+                quotedRaw.audioMessage?.viewOnce) {
+                innerMsg = quotedRaw;
+                isViewOnce = true;
+            }
+        }
+
+        return isViewOnce ? innerMsg : null;
+    }
+
     /**
      * Read and download view once message
      * @async
      * @param {Object} quotedMessage - The quoted message object (m.quoted)
-     * @returns {Promise<{buffer: Buffer, type: 'image'|'video', caption: string}>} Object containing media buffer, type, and caption
+     * @returns {Promise<{buffer: Buffer, type: 'image'|'video'|'audio', caption: string, mimetype?: string, ptt?: boolean}>} Object containing media buffer, type, and caption
      * @throws {Error} If quoted message is not provided or not a view once message
      * @example
      * const { buffer, type, caption } = await client.readViewOnce(m.quoted);
@@ -497,29 +565,100 @@ export class Client extends EventEmitter {
             throw new Error('Quoted message is required');
         }
 
-        // Get view once message
-        const ViewOnceImg = quotedMessage?.message?.imageMessage;
-        const ViewOnceVid = quotedMessage?.message?.videoMessage;
+        // Try to unwrap view once message
+        const innerMsg = this._unwrapViewOnceMessage(quotedMessage);
+
+        if (!innerMsg) {
+            throw new Error('Message is not a view once message or has already been opened');
+        }
+
+        // Extract media messages
+        const ViewOnceImg = innerMsg.imageMessage;
+        const ViewOnceVid = innerMsg.videoMessage;
+        const ViewOnceAud = innerMsg.audioMessage;
 
-        // Check if it's a view once message
-        if (!ViewOnceImg?.viewOnce && !ViewOnceVid?.viewOnce) {
-            throw new Error('Message is not a view once message');
+        // Get the media message
+        const mediaMsg = ViewOnceImg || ViewOnceVid || ViewOnceAud;
+
+        if (!mediaMsg) {
+            throw new Error('No media found in view once message');
         }
 
-        // Download the media
-        const buffer = await downloadMediaMessage(
-            quotedMessage,
-            'buffer',
-            {},
-            { logger: this.config.logger }
-        );
+        // Check if media key exists (if not, it's expired/opened)
+        if (!mediaMsg.mediaKey || mediaMsg.mediaKey.length === 0) {
+            throw new Error('View once message has been opened or expired. Reply to view once BEFORE it is opened.');
+        }
+
+        // Download the media with multiple fallback methods
+        let buffer = null;
+        const errors = [];
+
+        // Method 1: Try using quotedMessage.download() if available
+        if (typeof quotedMessage.download === 'function') {
+            try {
+                buffer = await quotedMessage.download();
+                this.config.logger?.debug('Downloaded view once using m.quoted.download()');
+            } catch (err) {
+                errors.push(`Method 1 (m.quoted.download): ${err.message}`);
+                this.config.logger?.debug('Download via m.quoted.download failed:', err.message);
+            }
+        }
+
+        // Method 2: Try downloadMediaMessage with innerMsg
+        if (!buffer) {
+            try {
+                buffer = await downloadMediaMessage(
+                    { message: innerMsg, key: quotedMessage.key },
+                    'buffer',
+                    {},
+                    { logger: this.config.logger }
+                );
+                this.config.logger?.debug('Downloaded view once using downloadMediaMessage with innerMsg');
+            } catch (err) {
+                errors.push(`Method 2 (downloadMediaMessage with innerMsg): ${err.message}`);
+                this.config.logger?.debug('Download via downloadMediaMessage (innerMsg) failed:', err.message);
+            }
+        }
+
+        // Method 3: Try downloadMediaMessage with original quotedMessage
+        if (!buffer) {
+            try {
+                buffer = await downloadMediaMessage(
+                    quotedMessage,
+                    'buffer',
+                    {},
+                    { logger: this.config.logger }
+                );
+                this.config.logger?.debug('Downloaded view once using downloadMediaMessage with quotedMessage');
+            } catch (err) {
+                errors.push(`Method 3 (downloadMediaMessage with quotedMessage): ${err.message}`);
+                this.config.logger?.debug('Download via downloadMediaMessage (quotedMessage) failed:', err.message);
+            }
+        }
+
+        if (!buffer) {
+            const errorMsg = `Failed to download view once media. Tried ${errors.length} methods:\n${errors.join('\n')}`;
+            this.config.logger?.error(errorMsg);
+            throw new Error(errorMsg);
+        }
 
         // Return buffer with type and caption
-        return {
+        const result = {
             buffer,
-            type: ViewOnceImg ? 'image' : 'video',
-            caption: ViewOnceImg?.caption || ViewOnceVid?.caption || ''
+            caption: ViewOnceImg?.caption || ViewOnceVid?.caption || ViewOnceAud?.caption || ''
         };
+
+        if (ViewOnceImg) {
+            result.type = 'image';
+        } else if (ViewOnceVid) {
+            result.type = 'video';
+        } else if (ViewOnceAud) {
+            result.type = 'audio';
+            result.mimetype = ViewOnceAud.mimetype || 'audio/mpeg';
+            result.ptt = !!ViewOnceAud.ptt;
+        }
+
+        return result;
     }
 
     /**
@@ -537,7 +676,8 @@ export class Client extends EventEmitter {
     async sendViewOnce(jid, quotedMessage, options = {}) {
         try {
             // Read the view once message
-            const { buffer, type, caption } = await this.readViewOnce(quotedMessage);
+            const result = await this.readViewOnce(quotedMessage);
+            const { buffer, type, caption, mimetype, ptt } = result;
 
             // Send based on type
             if (type === 'image') {
@@ -545,11 +685,19 @@ export class Client extends EventEmitter {
                     jpegThumbnail: null,
                     ...options
                 });
-            } else {
+            } else if (type === 'video') {
                 return await this.sendVideo(jid, buffer, caption, {
                     jpegThumbnail: null,
                     ...options
                 });
+            } else if (type === 'audio') {
+                return await this.sendAudio(jid, buffer, {
+                    mimetype: mimetype || 'audio/mpeg',
+                    ptt: ptt || false,
+                    ...options
+                });
+            } else {
+                throw new Error(`Unsupported view once media type: ${type}`);
             }
         } catch (error) {
             throw new Error(`Failed to send view once: ${error.message}`);

package/lib/index.d.ts

@@ -51,7 +51,13 @@ export class Client extends EventEmitter {
     sendReact(jid: string, messageKey: any, emoji: string): Promise<any>;
 
     // View once methods
-    readViewOnce(quotedMessage: any): Promise<{ buffer: Buffer, type: 'image' | 'video', caption: string }>;
+    readViewOnce(quotedMessage: any): Promise<{
+        buffer: Buffer;
+        type: 'image' | 'video' | 'audio';
+        caption: string;
+        mimetype?: string;
+        ptt?: boolean;
+    }>;
     sendViewOnce(jid: string, quotedMessage: any, options?: any): Promise<any>;
 
     // Group methods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roidev/kachina-md",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "WhatsApp Bot Framework - Simple, Fast, and Modular",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",