Examples

const { makeWASocket, useMultiFileAuthState, DisconnectReason } = require('socketon');
const pino = require('pino');

async function startBot() {
    const { state, saveCreds } = await useMultiFileAuthState('./auth');
    
    const sock = makeWASocket({
        logger: pino({ level: 'silent' }),
        auth: state,
        printQRInTerminal: true
    });

    sock.ev.on('connection.update', async (update) => {
        const { connection, lastDisconnect } = update;
        if (connection === 'close') {
            const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;
            if (shouldReconnect) startBot();
        } else if (connection === 'open') {
            console.log('Connected!');
        }
    });

    sock.ev.on('messages.upsert', async ({ messages }) => {
        const msg = messages[0];
        if (!msg.key.fromMe && msg.message) {
            const text = msg.message.conversation || msg.message.extendedTextMessage?.text;
            console.log('Message:', text);
        }
    });

    sock.ev.on('creds.update', saveCreds);
}

startBot();

const responses = {
    'hello': 'Hi there!',
    'hi': 'Hello!',
    'help': 'Available commands: help, info',
    'info': 'Socketon Bot v1.8.26'
};

sock.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    if (!msg.key.fromMe && msg.message) {
        const text = msg.message.conversation || msg.message.extendedTextMessage?.text;
        const reply = responses[text.toLowerCase()];
        
        if (reply) {
            await sock.sendMessage(msg.key.remoteJid, { text: reply }, { quoted: msg });
        }
    }
});

sock.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    if (!msg.key.fromMe && msg.message) {
        const text = msg.message.conversation || msg.message.extendedTextMessage?.text;
        const match = text.match(/^(\d+)\s*([+\-*/])\s*(\d+)$/);
        
        if (match) {
            const [, a, op, b] = match;
            let result;
            switch (op) {
                case '+': result = parseInt(a) + parseInt(b); break;
                case '-': result = parseInt(a) - parseInt(b); break;
                case '*': result = parseInt(a) * parseInt(b); break;
                case '/': result = parseInt(a) / parseInt(b); break;
            }
            await sock.sendMessage(msg.key.remoteJid, { text: `${a} ${op} ${b} = ${result}` }, { quoted: msg });
        }
    }
});

const forwardTo = '628xxxx@s.whatsapp.net';

sock.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    if (!msg.key.fromMe && msg.message) {
        await sock.sendMessage(forwardTo, {
            forward: msg
        });
        console.log('Message forwarded');
    }
});

const { downloadMediaMessage } = require('socketon').WAProto;
const fs = require('fs');

sock.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    if (!msg.key.fromMe && msg.message) {
        // Image
        if (msg.message.imageMessage) {
            const buffer = await downloadMediaMessage(msg);
            fs.writeFileSync('image.jpg', buffer);
        }
        
        // Video
        if (msg.message.videoMessage) {
            const buffer = await downloadMediaMessage(msg);
            fs.writeFileSync('video.mp4', buffer);
        }
        
        // Audio
        if (msg.message.audioMessage) {
            const buffer = await downloadMediaMessage(msg);
            fs.writeFileSync('audio.ogg', buffer);
        }
        
        // Document
        if (msg.message.documentMessage) {
            const buffer = await downloadMediaMessage(msg);
            const fileName = msg.message.documentMessage.fileName || 'file';
            fs.writeFileSync(fileName, buffer);
        }
    }
});

sock.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    if (!msg.message) return;
    
    const isGroup = msg.key.remoteJid.endsWith('@g.us');
    if (!isGroup) return;
    
    // Handle group creation
    if (msg.message.groupCreation) {
        await sock.sendMessage(msg.key.remoteJid, {
            text: 'Welcome to the group! 🎉'
        });
    }
    
    // Handle new member
    if (msg.message.groupParticipantChanged) {
        const participants = msg.message.groupParticipantChanged;
        const action = participants.action; // 'add', 'remove', 'promote', 'demote'
        const jid = participants.participants[0];
        
        if (action === 'add') {
            await sock.sendMessage(msg.key.remoteJid, {
                text: `Welcome @${jid.split('@')[0]}! 👋`
            }, { mentions: [jid] });
        }
    }
});

// Get newsletter ID from URL
const nlId = await sock.newsletterId('https://newsletter.com/channel');

// Follow
await sock.newsletterFollow(nlId);

// Listen to messages
sock.ev.on('messages.upsert', async ({ messages, type }) => {
    if (type !== 'notify') return;
    
    for (const msg of messages) {
        if (msg.key.remoteJid.includes('@newsletter')) {
            console.log('Newsletter message:', msg.message);
            
            // React
            await sock.newsletterReactMessage(
                msg.key.remoteJid,
                msg.key.id,
                '👍'
            );
            
            // Reply
            await sock.sendMessage(msg.key.remoteJid, {
                text: 'Thanks for the update!'
            });
        }
    }
});

const prefix = '!';
const commands = {
    ping: async (msg) => {
        await sock.sendMessage(msg.key.remoteJid, { text: 'Pong!' }, { quoted: msg });
    },
    about: async (msg) => {
        await sock.sendMessage(msg.key.remoteJid, { 
            text: 'Socketon Bot\nVersion: 1.8.26\nDeveloper: Ibra Decode' 
        }, { quoted: msg });
    },
    broadcast: async (msg, args) => {
        // Broadcast to all contacts
        const text = args.join(' ');
        // ... implementation
    }
};

sock.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    if (!msg.key.fromMe && msg.message) {
        const text = msg.message.conversation || msg.message.extendedTextMessage?.text;
        
        if (text.startsWith(prefix)) {
            const [cmd, ...args] = text.slice(1).split(' ');
            if (commands[cmd]) {
                await commands[cmd](msg, args);
            }
        }
    }
});

// Download from URL and send
const axios = require('axios');
const { downloadMediaMessage } = require('socketon').WAProto;

async function sendFromUrl(jid, url, type = 'image') {
    const response = await axios.get(url, { responseType: 'arraybuffer' });
    const buffer = Buffer.from(response.data);
    
    await sock.sendMessage(jid, {
        [type]: buffer
    });
}

// Usage
await sendFromUrl('628xxxx@s.whatsapp.net', 'https://example.com/image.jpg', 'image');
await sendFromUrl('628xxxx@s.whatsapp.net', 'https://example.com/video.mp4', 'video');

// Subscribe to presence
sock.presenceSubscribe('628xxxx@s.whatsapp.net');

// Listen to presence updates
sock.ev.on('presence.update', ({ id, presences }) => {
    for (const [participant, data] of Object.entries(presences)) {
        console.log(`${participant}: ${data.lastKnownPresence}`);
        if (data.lastSeen) {
            console.log(`Last seen: ${new Date(data.lastSeen * 1000)}`);
        }
    }
});