@deathnaitsa/wa-api 2.0.7 → 2.0.9

package/socket.js

@@ -4,6 +4,7 @@ import {
     sendText, 
     sendAudio,
     sendDocument,
+    sendImage,
     sendLocation,
     sendContact,
     sendReaction,
@@ -39,13 +40,44 @@ import {
     countReceivedMessage 
 } from '@deathnaitsa/wa-api';
 
+import https from 'https';
+import http from 'http';
+import { URL } from 'url';
+
 // Start sessions
 await startSession('bot');
-await startSession('bot2');
 
 // Command lock to prevent duplicate execution
 const commandLocks = new Map();
 
+// Helper: download a URL to a Buffer (follows redirects)
+async function fetchBuffer(url) {
+    return new Promise((resolve, reject) => {
+        try {
+            const parsed = new URL(url);
+            const lib = parsed.protocol === 'https:' ? https : http;
+            const req = lib.get(url, (res) => {
+                // follow redirects
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    return resolve(fetchBuffer(res.headers.location));
+                }
+                if (res.statusCode !== 200) {
+                    return reject(new Error(`Failed to fetch ${url}, status ${res.statusCode}`));
+                }
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => resolve(Buffer.concat(chunks)));
+            });
+            req.on('error', reject);
+            req.setTimeout(15000, () => {
+                req.destroy(new Error('Request timeout'));
+            });
+        } catch (err) {
+            reject(err);
+        }
+    });
+}
+
 async function acquireLock(key, timeoutMs = 5000) {
     const now = Date.now();
     const existing = commandLocks.get(key);
@@ -184,9 +216,23 @@ console.log('  !zuweisungen       - Alle Chat-Zuweisungen anzeigen\n');
 
 // WhatsApp message handler
 onMessage(async (msg) => {
-    // Ignore own messages
-    if (msg.fromMe) return;
+    // If a raw message object is present, normalize it using client's _parseMessage
+    try {
+        if (msg && msg.raw && client && typeof client._parseMessage === 'function') {
+            const normalized = client._parseMessage(msg.sessionId || 'bot', msg.raw);
+            if (normalized) {
+                // preserve original raw for debugging
+                normalized.raw = msg.raw;
+                msg = normalized;
+            }
+        }
+    } catch (e) {
+        console.error('[DEBUG] _parseMessage normalization failed:', e);
+    }
 
+    // Ignore own messages
+    if (!msg.fromMe) return;
+console.log('[DEBUG] Eingehende Nachricht:', msg);
     // Check if this message is assigned to this session
     if (!isAssignedToSession(msg.from, msg.sessionId)) {
         const assignedTo = getChatAssignment(msg.from);
@@ -200,23 +246,97 @@ onMessage(async (msg) => {
     // Mark when we received and started processing this message
     const messageProcessingStart = Date.now();
 
-    const [cmd, ...args] = msg.message.trim().split(' ');
+    // Parse command allowing a space after the bang, e.g. "! me" or variations in case
+    const rawText = (msg.message || '').trim();
+    let cmd = '';
+    let args = [];
+    const cmdMatch = rawText.match(/^!\s*([^\s]+)(?:\s+([\s\S]+))?$/i);
+    if (cmdMatch) {
+        cmd = '!' + cmdMatch[1];
+        args = cmdMatch[2] ? cmdMatch[2].trim().split(/\s+/) : [];
+    } else {
+        // fallback to simple split
+        [cmd, ...args] = rawText.split(/\s+/);
+    }
+
+    // Normalize command for case/spacing (e.g. !Me, ! me => !me)
+    const cmdNormalized = cmd.replace(/\s+/g, '').toLowerCase();
     const targetSession = args[0];
     
-    // Helper to safely send messages
-    const safeSend = async (text) => {
+    // Helper to safely send messages. Accepts string or payload objects.
+    const safeSend = async (payload) => {
         try {
             const sessions = client.getAllSessions();
-            if (sessions.includes(msg.sessionId)) {
-                await sendText(msg.sessionId, msg.from, text);
+            if (!sessions.includes(msg.sessionId)) return;
+
+            // If payload is a simple string, send as text
+            if (typeof payload === 'string') {
+                await sendText(msg.sessionId, msg.from, payload);
+                return;
+            }
+
+            // If payload is an object with an image Buffer or URL
+            if (payload && typeof payload === 'object') {
+                // image field
+                if (payload.image) {
+                    const img = payload.image;
+                    const caption = payload.caption || '';
+                    try {
+                        await sendImage(msg.sessionId, msg.from, img, caption);
+                        return;
+                    } catch (e) {
+                        // fallback to sendDocument using API signature: (sessionId, to, document, filename, mimetype, caption)
+                        try {
+                            const filename = payload.filename || 'image.jpg';
+                            const mimetype = payload.mimetype || 'image/jpeg';
+                            await sendDocument(msg.sessionId, msg.from, img, filename, mimetype, caption);
+                            return;
+                        } catch (err) {
+                            throw err;
+                        }
+                    }
+                }
+
+                // document field
+                if (payload.document) {
+                    // payload.document can be Buffer or an object { data, filename, mimetype, caption }
+                    const doc = payload.document;
+                    if (Buffer.isBuffer(doc)) {
+                        await sendDocument(msg.sessionId, msg.from, doc);
+                    } else if (doc && typeof doc === 'object') {
+                        const data = doc.data || doc;
+                        const filename = doc.filename || payload.filename || 'file.bin';
+                        const mimetype = doc.mimetype || 'application/octet-stream';
+                        const caption = doc.caption || payload.caption || '';
+                        await sendDocument(msg.sessionId, msg.from, data, filename, mimetype, caption);
+                    } else {
+                        await sendDocument(msg.sessionId, msg.from, doc);
+                    }
+                    return;
+                }
+
+                // generic buffer with caption
+                if (Buffer.isBuffer(payload)) {
+                    try {
+                        await sendImage(msg.sessionId, msg.from, payload, payload.caption || '');
+                        return;
+                    } catch (e) {
+                        // fallback to sendDocument with filename
+                        await sendDocument(msg.sessionId, msg.from, payload, 'file.jpg', 'image/jpeg', payload.caption || '');
+                        return;
+                    }
+                }
             }
+
+            // Unsupported payload type
+            console.error('safeSend: Unsupported payload type', typeof payload);
         } catch (e) {
             console.error('Could not send message:', e.message);
         }
     };
 
     try {
-        switch (cmd) {
+        switch (cmdNormalized) {
             case '!ping':
                 if (targetSession === 'all') {
                     // Test all sessions
@@ -581,62 +701,170 @@ onMessage(async (msg) => {
 
             case '!profilbild':
                 try {
-                    // Get sender's JID (use participant if in group)
-                    const senderJid = msg.isGroup ? msg.participant : msg.from;
-                    const url = await getProfilePicture(msg.sessionId, senderJid);
-                    
-                    if (url) {
-                        await safeSend(`🖼️ *Profilbild:*\n\n${url}`);
-                    } else {
-                        await safeSend('❌ Kein Profilbild vorhanden');
+                    const targets = new Set();
+
+                    // args 'me' refers to the sender (participant in group or from in private)
+                    if (args[0] && args[0].toLowerCase() === 'me') {
+                        // Use msg.sender when available (explicit sender of the message),
+                        // otherwise fall back to participant (group) or from (private)
+                        targets.add(msg.sender || (msg.isGroup ? msg.participant : msg.from));
+                    }
+
+                    // mentions: support several possible shapes coming from parser
+                    const mentionList = new Set();
+                    const ctxMentioned = msg.raw?.message?.extendedTextMessage?.contextInfo?.mentionedJid;
+                    if (Array.isArray(ctxMentioned)) for (const m of ctxMentioned) mentionList.add(m);
+                    // older/other parsers may expose msg.mentionedJid or msg.mentions
+                    if (msg.mentionedJid) {
+                        if (Array.isArray(msg.mentionedJid)) for (const m of msg.mentionedJid) mentionList.add(m);
+                        else if (typeof msg.mentionedJid === 'string' && msg.mentionedJid) mentionList.add(msg.mentionedJid);
+                    }
+                    if (msg.mentions) {
+                        if (Array.isArray(msg.mentions)) for (const m of msg.mentions) mentionList.add(m);
+                        else if (typeof msg.mentions === 'string' && msg.mentions) mentionList.add(msg.mentions);
+                    }
+                    // also include msg.mentions parsed earlier (single string) if present
+                    if (msg.mentions && typeof msg.mentions === 'string' && msg.mentions.includes('@')) mentionList.add(msg.mentions);
+                    for (const m of mentionList) targets.add(m);
+
+                    // quoted participant
+                    if (msg.quoted && msg.quoted.participant) targets.add(msg.quoted.participant);
+
+                    // if an explicit phone/JID was provided as arg (e.g. !profilbild 49123...)
+                    if (args && args.length && !args[0].toLowerCase().startsWith('me')) {
+                        const maybe = args[0].replace(/[^0-9@.]/g, '');
+                        if (maybe.includes('@')) targets.add(maybe);
+                        else if (maybe) targets.add(`${maybe}@s.whatsapp.net`);
+                    }
+
+                    if (targets.size === 0) {
+                        targets.add(msg.isGroup ? msg.participant : msg.from);
+                    }
+
+                    for (const t of targets) {
+                        try {
+                            const mentionJid = (msg.isGroup && t === msg.from) ? msg.participant : t;
+                            const shortName = mentionJid.split('@')[0];
+
+                            const pic = await getProfilePicture(msg.sessionId, t);
+                            let buf = null;
+
+                            if (!pic) {
+                                // no profile picture
+                                await client.sendMessage(msg.sessionId, msg.from, { text: `❌ Kein Profilbild für ${shortName} gefunden` });
+                                continue;
+                            }
+
+                            if (Buffer.isBuffer(pic)) buf = pic;
+                            else if (typeof pic === 'string') {
+                                try {
+                                    buf = await fetchBuffer(pic);
+                                } catch (e) {
+                                    console.error('[DEBUG] Fehler beim Herunterladen des Profilbildes:', e.message);
+                                }
+                            }
+
+                            if (buf) {
+                                const caption = `🖼️ Profilbild von ${shortName}`;
+                                try {
+                                    await sendImage(msg.sessionId, msg.from, buf, caption);
+                                } catch (e) {
+                                    console.error('[DEBUG] sendImage failed:', e.message);
+                                    // fallback to sendDocument
+                                    try {
+                                        await sendDocument(msg.sessionId, msg.from, buf, `${shortName}.jpg`, 'image/jpeg', caption);
+                                    } catch (err) {
+                                        console.error('[DEBUG] sendDocument fallback failed:', err.message);
+                                    }
+                                }
+
+                                // send a tagged text so the user is mentioned (sendText doesn't support mentions)
+                                try {
+                                    await client.sendMessage(msg.sessionId, msg.from, { text: `🖼️ Profilbild von @${shortName}`, mentions: [mentionJid] });
+                                } catch (_) {
+                                    try { await sendText(msg.sessionId, msg.from, `🖼️ Profilbild von ${shortName}`); } catch(_){}
+                                }
+                            } else if (typeof pic === 'string') {
+                                // couldn't download buffer, send link and mention
+                                try {
+                                    await client.sendMessage(msg.sessionId, msg.from, { text: `🖼️ Profilbild von @${shortName}:\n${pic}`, mentions: [mentionJid] });
+                                } catch (_) {
+                                    await sendText(msg.sessionId, msg.from, `🖼️ Profilbild von ${shortName}:\n${pic}`);
+                                }
+                            }
+                        } catch (e) {
+                            console.error('[DEBUG] Fehler beim Abrufen Profilbild:', e);
+                            try { await sendText(msg.sessionId, msg.from, `❌ Fehler beim Abrufen von ${t.split('@')[0]}: ${e.message}`); } catch(_){}
+                        }
                     }
                 } catch (e) {
-                    await safeSend(`❌ Fehler: ${e.message}`);
+                    try { await sendText(msg.sessionId, msg.from, `❌ Fehler: ${e.message}`); } catch(_){}
                 }
                 break;
 
             case '!status':
                 try {
                     const senderJid = msg.isGroup ? msg.participant : msg.from;
-                    const status = await getStatus(msg.sessionId, senderJid);
-                    
-                    if (status?.status) {
-                        await safeSend(`💬 *Status:*\n\n${status.status}`);
+                    console.log(`[DEBUG] getStatus aufgerufen für Session: ${msg.sessionId}, JID: ${senderJid}`);
+                    let status = await getStatus(msg.sessionId, senderJid);
+                    console.log('[DEBUG] getStatus Rückgabe:', status);
+
+                    // Manche Implementierungen liefern ein Array von Status-Objekten
+                    if (Array.isArray(status) && status.length > 0) {
+                        // Nimm das erste Element (neuester Status)
+                        status = status[0];
+                    }
+
+                    // Falls das Objekt innerhalb eines Wrappers das Feld `status` hat
+                    const statusText = status?.status?.status || status?.status || (typeof status === 'string' ? status : null);
+
+                    if (statusText) {
+                        await safeSend(`💬 *Status:*\n\n${statusText}`);
                     } else {
                         await safeSend('❌ Kein Status vorhanden');
                     }
                 } catch (e) {
+                    console.error('[DEBUG] Fehler bei getStatus:', e);
                     await safeSend(`❌ Fehler: ${e.message}`);
                 }
                 break;
 
             case '!kontakt':
                 try {
-                    const senderJid = msg.isGroup ? msg.participant : msg.from;
+                    const senderJid = msg.isGroup ? msg.mentions : msg.mentions
+                    console.log(`[DEBUG] getContact aufgerufen für Session: ${msg.sessionId}, JID: ${senderJid}`);
                     const contact = await getContact(msg.sessionId, senderJid);
-                    
-                    let contactInfo = `👤 *Kontaktinfo:*\n\n`;
+
+                    // Guard: getContact may return undefined/null
+                    if (!contact || !contact.jid) {
+                        console.error('[DEBUG] getContact returned empty for', senderJid, contact);
+                        await safeSend(`❌ Kontakt nicht gefunden für ${senderJid.split('@')[0] || senderJid}`);
+                        break;
+                    }
+
+                    let contactInfo = `👤 *Kontaktinfo:\n\n`;
                     contactInfo += `JID: ${contact.jid}\n`;
                     contactInfo += `Nummer: ${contact.jid.split('@')[0]}\n`;
                     contactInfo += `Exists: ${contact.exists ? 'Ja' : 'Nein'}\n`;
-                    
                     await safeSend(contactInfo);
                 } catch (e) {
                     await safeSend(`❌ Fehler: ${e.message}`);
                 }
                 break;
 
-            case '!meinestatus':
+            case '!meinstatus':
                 const newStatus = args.join(' ');
                 if (!newStatus) {
-                    await safeSend('❌ Verwendung: !meinestatus <neuer Status>');
+                    await safeSend('❌ Verwendung: !meinstatus <neuer Status>');
                     break;
                 }
-                
                 try {
-                    await updateProfileStatus(msg.sessionId, newStatus);
+                    console.log(`[DEBUG] updateProfileStatus aufgerufen für Session: ${msg.sessionId}, Status: ${newStatus}`);
+                    const result = await updateProfileStatus(msg.sessionId, newStatus);
+                    console.log(`[DEBUG] updateProfileStatus Rückgabe:`, result);
                     await safeSend(`✅ Status geändert zu: "${newStatus}"`);
                 } catch (e) {
+                    console.error('[DEBUG] Fehler bei updateProfileStatus:', e);
                     await safeSend(`❌ Fehler: ${e.message}`);
                 }
                 break;